﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using UniRx.Operators;
using UniRx.Triggers;
using UnityEngine;

namespace UniRx
{
	// Token: 0x02000201 RID: 513
	public static class Observable
	{
		// Token: 0x06000ACC RID: 2764 RVA: 0x000395A8 File Offset: 0x000379A8
		private static IObservable<T> AddRef<T>(IObservable<T> xs, RefCountDisposable r)
		{
			return Observable.Create<T>((IObserver<T> observer) => new CompositeDisposable(new IDisposable[]
			{
				r.GetDisposable(),
				xs.Subscribe(observer)
			}));
		}

		// Token: 0x06000ACD RID: 2765 RVA: 0x000395DA File Offset: 0x000379DA
		public static IObservable<T> Scan<T>(this IObservable<T> source, Func<T, T, T> accumulator)
		{
			return new ScanObservable<T>(source, accumulator);
		}

		// Token: 0x06000ACE RID: 2766 RVA: 0x000395E3 File Offset: 0x000379E3
		public static IObservable<TAccumulate> Scan<T, TAccumulate>(this IObservable<T> source, TAccumulate seed, Func<TAccumulate, T, TAccumulate> accumulator)
		{
			return new ScanObservable<T, TAccumulate>(source, seed, accumulator);
		}

		// Token: 0x06000ACF RID: 2767 RVA: 0x000395ED File Offset: 0x000379ED
		public static IObservable<T> Aggregate<T>(this IObservable<T> source, Func<T, T, T> accumulator)
		{
			return new AggregateObservable<T>(source, accumulator);
		}

		// Token: 0x06000AD0 RID: 2768 RVA: 0x000395F6 File Offset: 0x000379F6
		public static IObservable<TAccumulate> Aggregate<T, TAccumulate>(this IObservable<T> source, TAccumulate seed, Func<TAccumulate, T, TAccumulate> accumulator)
		{
			return new AggregateObservable<T, TAccumulate>(source, seed, accumulator);
		}

		// Token: 0x06000AD1 RID: 2769 RVA: 0x00039600 File Offset: 0x00037A00
		public static IObservable<TResult> Aggregate<T, TAccumulate, TResult>(this IObservable<T> source, TAccumulate seed, Func<TAccumulate, T, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector)
		{
			return new AggregateObservable<T, TAccumulate, TResult>(source, seed, accumulator, resultSelector);
		}

		// Token: 0x06000AD2 RID: 2770 RVA: 0x0003960B File Offset: 0x00037A0B
		public static IConnectableObservable<T> Multicast<T>(this IObservable<T> source, ISubject<T> subject)
		{
			return new Observable.ConnectableObservable<T>(source, subject);
		}

		// Token: 0x06000AD3 RID: 2771 RVA: 0x00039614 File Offset: 0x00037A14
		public static IConnectableObservable<T> Publish<T>(this IObservable<T> source)
		{
			return source.Multicast(new Subject<T>());
		}

		// Token: 0x06000AD4 RID: 2772 RVA: 0x00039621 File Offset: 0x00037A21
		public static IConnectableObservable<T> Publish<T>(this IObservable<T> source, T initialValue)
		{
			return source.Multicast(new BehaviorSubject<T>(initialValue));
		}

		// Token: 0x06000AD5 RID: 2773 RVA: 0x0003962F File Offset: 0x00037A2F
		public static IConnectableObservable<T> PublishLast<T>(this IObservable<T> source)
		{
			return source.Multicast(new AsyncSubject<T>());
		}

		// Token: 0x06000AD6 RID: 2774 RVA: 0x0003963C File Offset: 0x00037A3C
		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source)
		{
			return source.Multicast(new ReplaySubject<T>());
		}

		// Token: 0x06000AD7 RID: 2775 RVA: 0x00039649 File Offset: 0x00037A49
		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(scheduler));
		}

		// Token: 0x06000AD8 RID: 2776 RVA: 0x00039657 File Offset: 0x00037A57
		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, int bufferSize)
		{
			return source.Multicast(new ReplaySubject<T>(bufferSize));
		}

		// Token: 0x06000AD9 RID: 2777 RVA: 0x00039665 File Offset: 0x00037A65
		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, int bufferSize, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(bufferSize, scheduler));
		}

		// Token: 0x06000ADA RID: 2778 RVA: 0x00039674 File Offset: 0x00037A74
		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, TimeSpan window)
		{
			return source.Multicast(new ReplaySubject<T>(window));
		}

		// Token: 0x06000ADB RID: 2779 RVA: 0x00039682 File Offset: 0x00037A82
		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, TimeSpan window, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(window, scheduler));
		}

		// Token: 0x06000ADC RID: 2780 RVA: 0x00039691 File Offset: 0x00037A91
		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, int bufferSize, TimeSpan window, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(bufferSize, window, scheduler));
		}

		// Token: 0x06000ADD RID: 2781 RVA: 0x000396A1 File Offset: 0x00037AA1
		public static IObservable<T> RefCount<T>(this IConnectableObservable<T> source)
		{
			return new RefCountObservable<T>(source);
		}

		// Token: 0x06000ADE RID: 2782 RVA: 0x000396A9 File Offset: 0x00037AA9
		public static IObservable<T> Share<T>(this IObservable<T> source)
		{
			return source.Publish<T>().RefCount<T>();
		}

		// Token: 0x06000ADF RID: 2783 RVA: 0x000396B6 File Offset: 0x00037AB6
		public static T Wait<T>(this IObservable<T> source)
		{
			return new Wait<T>(source, Observable.InfiniteTimeSpan).Run();
		}

		// Token: 0x06000AE0 RID: 2784 RVA: 0x000396C8 File Offset: 0x00037AC8
		public static T Wait<T>(this IObservable<T> source, TimeSpan timeout)
		{
			return new Wait<T>(source, timeout).Run();
		}

		// Token: 0x06000AE1 RID: 2785 RVA: 0x000396D8 File Offset: 0x00037AD8
		private static IEnumerable<IObservable<T>> CombineSources<T>(IObservable<T> first, IObservable<T>[] seconds)
		{
			yield return first;
			for (int i = 0; i < seconds.Length; i++)
			{
				yield return seconds[i];
			}
			yield break;
		}

		// Token: 0x06000AE2 RID: 2786 RVA: 0x00039702 File Offset: 0x00037B02
		public static IObservable<T> Concat<T>(params IObservable<T>[] sources)
		{
			if (sources == null)
			{
				throw new ArgumentNullException("sources");
			}
			return new ConcatObservable<T>(sources);
		}

		// Token: 0x06000AE3 RID: 2787 RVA: 0x0003971B File Offset: 0x00037B1B
		public static IObservable<T> Concat<T>(this IEnumerable<IObservable<T>> sources)
		{
			if (sources == null)
			{
				throw new ArgumentNullException("sources");
			}
			return new ConcatObservable<T>(sources);
		}

		// Token: 0x06000AE4 RID: 2788 RVA: 0x00039734 File Offset: 0x00037B34
		public static IObservable<T> Concat<T>(this IObservable<IObservable<T>> sources)
		{
			return sources.Merge(1);
		}

		// Token: 0x06000AE5 RID: 2789 RVA: 0x00039740 File Offset: 0x00037B40
		public static IObservable<T> Concat<T>(this IObservable<T> first, params IObservable<T>[] seconds)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (seconds == null)
			{
				throw new ArgumentNullException("seconds");
			}
			ConcatObservable<T> concatObservable = first as ConcatObservable<T>;
			if (concatObservable != null)
			{
				return concatObservable.Combine(seconds);
			}
			return Observable.CombineSources<T>(first, seconds).Concat<T>();
		}

		// Token: 0x06000AE6 RID: 2790 RVA: 0x00039790 File Offset: 0x00037B90
		public static IObservable<T> Merge<T>(this IEnumerable<IObservable<T>> sources)
		{
			return sources.Merge(Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		// Token: 0x06000AE7 RID: 2791 RVA: 0x0003979D File Offset: 0x00037B9D
		public static IObservable<T> Merge<T>(this IEnumerable<IObservable<T>> sources, IScheduler scheduler)
		{
			return new MergeObservable<T>(sources.ToObservable(scheduler), scheduler == Scheduler.CurrentThread);
		}

		// Token: 0x06000AE8 RID: 2792 RVA: 0x000397B3 File Offset: 0x00037BB3
		public static IObservable<T> Merge<T>(this IEnumerable<IObservable<T>> sources, int maxConcurrent)
		{
			return sources.Merge(maxConcurrent, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		// Token: 0x06000AE9 RID: 2793 RVA: 0x000397C1 File Offset: 0x00037BC1
		public static IObservable<T> Merge<T>(this IEnumerable<IObservable<T>> sources, int maxConcurrent, IScheduler scheduler)
		{
			return new MergeObservable<T>(sources.ToObservable(scheduler), maxConcurrent, scheduler == Scheduler.CurrentThread);
		}

		// Token: 0x06000AEA RID: 2794 RVA: 0x000397D8 File Offset: 0x00037BD8
		public static IObservable<T> Merge<T>(params IObservable<T>[] sources)
		{
			return Observable.Merge<T>(Scheduler.DefaultSchedulers.ConstantTimeOperations, sources);
		}

		// Token: 0x06000AEB RID: 2795 RVA: 0x000397E5 File Offset: 0x00037BE5
		public static IObservable<T> Merge<T>(IScheduler scheduler, params IObservable<T>[] sources)
		{
			return new MergeObservable<T>(sources.ToObservable(scheduler), scheduler == Scheduler.CurrentThread);
		}

		// Token: 0x06000AEC RID: 2796 RVA: 0x000397FB File Offset: 0x00037BFB
		public static IObservable<T> Merge<T>(this IObservable<T> first, params IObservable<T>[] seconds)
		{
			return Observable.CombineSources<T>(first, seconds).Merge<T>();
		}

		// Token: 0x06000AED RID: 2797 RVA: 0x00039809 File Offset: 0x00037C09
		public static IObservable<T> Merge<T>(this IObservable<T> first, IObservable<T> second, IScheduler scheduler)
		{
			return Observable.Merge<T>(scheduler, new IObservable<T>[]
			{
				first,
				second
			});
		}

		// Token: 0x06000AEE RID: 2798 RVA: 0x0003981F File Offset: 0x00037C1F
		public static IObservable<T> Merge<T>(this IObservable<IObservable<T>> sources)
		{
			return new MergeObservable<T>(sources, false);
		}

		// Token: 0x06000AEF RID: 2799 RVA: 0x00039828 File Offset: 0x00037C28
		public static IObservable<T> Merge<T>(this IObservable<IObservable<T>> sources, int maxConcurrent)
		{
			return new MergeObservable<T>(sources, maxConcurrent, false);
		}

		// Token: 0x06000AF0 RID: 2800 RVA: 0x00039832 File Offset: 0x00037C32
		public static IObservable<TResult> Zip<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new ZipObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		// Token: 0x06000AF1 RID: 2801 RVA: 0x0003983C File Offset: 0x00037C3C
		public static IObservable<IList<T>> Zip<T>(this IEnumerable<IObservable<T>> sources)
		{
			return Observable.Zip<T>(sources.ToArray<IObservable<T>>());
		}

		// Token: 0x06000AF2 RID: 2802 RVA: 0x00039849 File Offset: 0x00037C49
		public static IObservable<IList<T>> Zip<T>(params IObservable<T>[] sources)
		{
			return new ZipObservable<T>(sources);
		}

		// Token: 0x06000AF3 RID: 2803 RVA: 0x00039851 File Offset: 0x00037C51
		public static IObservable<TR> Zip<T1, T2, T3, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, ZipFunc<T1, T2, T3, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, TR>(source1, source2, source3, resultSelector);
		}

		// Token: 0x06000AF4 RID: 2804 RVA: 0x0003985C File Offset: 0x00037C5C
		public static IObservable<TR> Zip<T1, T2, T3, T4, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, ZipFunc<T1, T2, T3, T4, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, TR>(source1, source2, source3, source4, resultSelector);
		}

		// Token: 0x06000AF5 RID: 2805 RVA: 0x00039869 File Offset: 0x00037C69
		public static IObservable<TR> Zip<T1, T2, T3, T4, T5, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, ZipFunc<T1, T2, T3, T4, T5, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, T5, TR>(source1, source2, source3, source4, source5, resultSelector);
		}

		// Token: 0x06000AF6 RID: 2806 RVA: 0x00039878 File Offset: 0x00037C78
		public static IObservable<TR> Zip<T1, T2, T3, T4, T5, T6, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, ZipFunc<T1, T2, T3, T4, T5, T6, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, T5, T6, TR>(source1, source2, source3, source4, source5, source6, resultSelector);
		}

		// Token: 0x06000AF7 RID: 2807 RVA: 0x00039889 File Offset: 0x00037C89
		public static IObservable<TR> Zip<T1, T2, T3, T4, T5, T6, T7, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, ZipFunc<T1, T2, T3, T4, T5, T6, T7, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, T5, T6, T7, TR>(source1, source2, source3, source4, source5, source6, source7, resultSelector);
		}

		// Token: 0x06000AF8 RID: 2808 RVA: 0x0003989C File Offset: 0x00037C9C
		public static IObservable<TResult> CombineLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new CombineLatestObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		// Token: 0x06000AF9 RID: 2809 RVA: 0x000398A6 File Offset: 0x00037CA6
		public static IObservable<IList<T>> CombineLatest<T>(this IEnumerable<IObservable<T>> sources)
		{
			return Observable.CombineLatest<T>(sources.ToArray<IObservable<T>>());
		}

		// Token: 0x06000AFA RID: 2810 RVA: 0x000398B3 File Offset: 0x00037CB3
		public static IObservable<IList<T>> CombineLatest<T>(params IObservable<T>[] sources)
		{
			return new CombineLatestObservable<T>(sources);
		}

		// Token: 0x06000AFB RID: 2811 RVA: 0x000398BB File Offset: 0x00037CBB
		public static IObservable<TR> CombineLatest<T1, T2, T3, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, CombineLatestFunc<T1, T2, T3, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, TR>(source1, source2, source3, resultSelector);
		}

		// Token: 0x06000AFC RID: 2812 RVA: 0x000398C6 File Offset: 0x00037CC6
		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, CombineLatestFunc<T1, T2, T3, T4, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, TR>(source1, source2, source3, source4, resultSelector);
		}

		// Token: 0x06000AFD RID: 2813 RVA: 0x000398D3 File Offset: 0x00037CD3
		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, T5, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, CombineLatestFunc<T1, T2, T3, T4, T5, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, T5, TR>(source1, source2, source3, source4, source5, resultSelector);
		}

		// Token: 0x06000AFE RID: 2814 RVA: 0x000398E2 File Offset: 0x00037CE2
		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, T5, T6, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, CombineLatestFunc<T1, T2, T3, T4, T5, T6, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, T5, T6, TR>(source1, source2, source3, source4, source5, source6, resultSelector);
		}

		// Token: 0x06000AFF RID: 2815 RVA: 0x000398F3 File Offset: 0x00037CF3
		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, T5, T6, T7, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, CombineLatestFunc<T1, T2, T3, T4, T5, T6, T7, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, T5, T6, T7, TR>(source1, source2, source3, source4, source5, source6, source7, resultSelector);
		}

		// Token: 0x06000B00 RID: 2816 RVA: 0x00039906 File Offset: 0x00037D06
		public static IObservable<TResult> ZipLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new ZipLatestObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		// Token: 0x06000B01 RID: 2817 RVA: 0x00039910 File Offset: 0x00037D10
		public static IObservable<IList<T>> ZipLatest<T>(this IEnumerable<IObservable<T>> sources)
		{
			return Observable.ZipLatest<T>(sources.ToArray<IObservable<T>>());
		}

		// Token: 0x06000B02 RID: 2818 RVA: 0x0003991D File Offset: 0x00037D1D
		public static IObservable<IList<T>> ZipLatest<T>(params IObservable<T>[] sources)
		{
			return new ZipLatestObservable<T>(sources);
		}

		// Token: 0x06000B03 RID: 2819 RVA: 0x00039925 File Offset: 0x00037D25
		public static IObservable<TR> ZipLatest<T1, T2, T3, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, ZipLatestFunc<T1, T2, T3, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, TR>(source1, source2, source3, resultSelector);
		}

		// Token: 0x06000B04 RID: 2820 RVA: 0x00039930 File Offset: 0x00037D30
		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, ZipLatestFunc<T1, T2, T3, T4, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, TR> (source1, source2, source3, source4, resultSelector);
		}

		// Token: 0x06000B05 RID: 2821 RVA: 0x0003993D File Offset: 0x00037D3D
		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, T5, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, ZipLatestFunc<T1, T2, T3, T4, T5, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, T5, TR > (source1, source2, source3, source4, source5, resultSelector);
		}

		// Token: 0x06000B06 RID: 2822 RVA: 0x0003994C File Offset: 0x00037D4C
		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, T5, T6, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, ZipLatestFunc<T1, T2, T3, T4, T5, T6, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, T5, T6, TR>(source1, source2, source3, source4, source5, source6, resultSelector);
		}

		// Token: 0x06000B07 RID: 2823 RVA: 0x0003995D File Offset: 0x00037D5D
		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, T5, T6, T7, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, ZipLatestFunc<T1, T2, T3, T4, T5, T6, T7, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, T5, T6, T7, TR>(source1, source2, source3, source4, source5, source6, source7, resultSelector);
		}

		// Token: 0x06000B08 RID: 2824 RVA: 0x00039970 File Offset: 0x00037D70
		public static IObservable<T> Switch<T>(this IObservable<IObservable<T>> sources)
		{
			return new SwitchObservable<T>(sources);
		}

		// Token: 0x06000B09 RID: 2825 RVA: 0x00039978 File Offset: 0x00037D78
		public static IObservable<TResult> WithLatestFrom<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new WithLatestFromObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		// Token: 0x06000B0A RID: 2826 RVA: 0x00039982 File Offset: 0x00037D82
		public static IObservable<T[]> WhenAll<T>(params IObservable<T>[] sources)
		{
			if (sources.Length == 0)
			{
				return Observable.Return<T[]>(new T[0]);
			}
			return new WhenAllObservable<T>(sources);
		}

		// Token: 0x06000B0B RID: 2827 RVA: 0x0003999E File Offset: 0x00037D9E
		public static IObservable<Unit> WhenAll(params IObservable<Unit>[] sources)
		{
			if (sources.Length == 0)
			{
				return Observable.ReturnUnit();
			}
			return new WhenAllObservable(sources);
		}

		// Token: 0x06000B0C RID: 2828 RVA: 0x000399B4 File Offset: 0x00037DB4
		public static IObservable<T[]> WhenAll<T>(this IEnumerable<IObservable<T>> sources)
		{
			IObservable<T>[] array = sources as IObservable<T>[];
			if (array != null)
			{
				return Observable.WhenAll<T>(array);
			}
			return new WhenAllObservable<T>(sources);
		}

		// Token: 0x06000B0D RID: 2829 RVA: 0x000399DC File Offset: 0x00037DDC
		public static IObservable<Unit> WhenAll(this IEnumerable<IObservable<Unit>> sources)
		{
			IObservable<Unit>[] array = sources as IObservable<Unit>[];
			if (array != null)
			{
				return Observable.WhenAll(array);
			}
			return new WhenAllObservable(sources);
		}

		// Token: 0x06000B0E RID: 2830 RVA: 0x00039A03 File Offset: 0x00037E03
		public static IObservable<T> StartWith<T>(this IObservable<T> source, T value)
		{
			return new StartWithObservable<T>(source, value);
		}

		// Token: 0x06000B0F RID: 2831 RVA: 0x00039A0C File Offset: 0x00037E0C
		public static IObservable<T> StartWith<T>(this IObservable<T> source, Func<T> valueFactory)
		{
			return new StartWithObservable<T>(source, valueFactory);
		}

		// Token: 0x06000B10 RID: 2832 RVA: 0x00039A15 File Offset: 0x00037E15
		public static IObservable<T> StartWith<T>(this IObservable<T> source, params T[] values)
		{
			return source.StartWith(Scheduler.DefaultSchedulers.ConstantTimeOperations, values);
		}

		// Token: 0x06000B11 RID: 2833 RVA: 0x00039A23 File Offset: 0x00037E23
		public static IObservable<T> StartWith<T>(this IObservable<T> source, IEnumerable<T> values)
		{
			return source.StartWith(Scheduler.DefaultSchedulers.ConstantTimeOperations, values);
		}

		// Token: 0x06000B12 RID: 2834 RVA: 0x00039A31 File Offset: 0x00037E31
		public static IObservable<T> StartWith<T>(this IObservable<T> source, IScheduler scheduler, T value)
		{
			return Observable.Return<T>(value, scheduler).Concat(new IObservable<T>[]
			{
				source
			});
		}

		// Token: 0x06000B13 RID: 2835 RVA: 0x00039A4C File Offset: 0x00037E4C
		public static IObservable<T> StartWith<T>(this IObservable<T> source, IScheduler scheduler, IEnumerable<T> values)
		{
			T[] array = values as T[];
			if (array == null)
			{
				array = values.ToArray<T>();
			}
			return source.StartWith(scheduler, array);
		}

		// Token: 0x06000B14 RID: 2836 RVA: 0x00039A75 File Offset: 0x00037E75
		public static IObservable<T> StartWith<T>(this IObservable<T> source, IScheduler scheduler, params T[] values)
		{
			return values.ToObservable(scheduler).Concat(new IObservable<T>[]
			{
				source
			});
		}

		// Token: 0x06000B15 RID: 2837 RVA: 0x00039A8D File Offset: 0x00037E8D
		public static IObservable<T> Synchronize<T>(this IObservable<T> source)
		{
			return new SynchronizeObservable<T>(source, new object());
		}

		// Token: 0x06000B16 RID: 2838 RVA: 0x00039A9A File Offset: 0x00037E9A
		public static IObservable<T> Synchronize<T>(this IObservable<T> source, object gate)
		{
			return new SynchronizeObservable<T>(source, gate);
		}

		// Token: 0x06000B17 RID: 2839 RVA: 0x00039AA3 File Offset: 0x00037EA3
		public static IObservable<T> ObserveOn<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return new ObserveOnObservable<T>(source, scheduler);
		}

		// Token: 0x06000B18 RID: 2840 RVA: 0x00039AAC File Offset: 0x00037EAC
		public static IObservable<T> SubscribeOn<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return new SubscribeOnObservable<T>(source, scheduler);
		}

		// Token: 0x06000B19 RID: 2841 RVA: 0x00039AB5 File Offset: 0x00037EB5
		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, TimeSpan dueTime)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B1A RID: 2842 RVA: 0x00039AC3 File Offset: 0x00037EC3
		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, TimeSpan dueTime, IScheduler scheduler)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, scheduler);
		}

		// Token: 0x06000B1B RID: 2843 RVA: 0x00039ACD File Offset: 0x00037ECD
		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, DateTimeOffset dueTime)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B1C RID: 2844 RVA: 0x00039ADB File Offset: 0x00037EDB
		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, DateTimeOffset dueTime, IScheduler scheduler)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, scheduler);
		}

		// Token: 0x06000B1D RID: 2845 RVA: 0x00039AE5 File Offset: 0x00037EE5
		public static IObservable<T> Amb<T>(params IObservable<T>[] sources)
		{
			return Observable.Amb<T>(sources);
		}

		// Token: 0x06000B1E RID: 2846 RVA: 0x00039AF0 File Offset: 0x00037EF0
		public static IObservable<T> Amb<T>(IEnumerable<IObservable<T>> sources)
		{
			IObservable<T> observable = Observable.Never<T>();
			foreach (IObservable<T> observable2 in sources)
			{
				IObservable<T> second = observable2;
				observable = observable.Amb(second);
			}
			return observable;
		}

		// Token: 0x06000B1F RID: 2847 RVA: 0x00039B50 File Offset: 0x00037F50
		public static IObservable<T> Amb<T>(this IObservable<T> source, IObservable<T> second)
		{
			return new AmbObservable<T>(source, second);
		}

		// Token: 0x06000B20 RID: 2848 RVA: 0x00039B59 File Offset: 0x00037F59
		public static IObservable<T> AsObservable<T>(this IObservable<T> source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (source is AsObservableObservable<T>)
			{
				return source;
			}
			return new AsObservableObservable<T>(source);
		}

		// Token: 0x06000B21 RID: 2849 RVA: 0x00039B7F File Offset: 0x00037F7F
		public static IObservable<T> ToObservable<T>(this IEnumerable<T> source)
		{
			return source.ToObservable(Scheduler.DefaultSchedulers.Iteration);
		}

		// Token: 0x06000B22 RID: 2850 RVA: 0x00039B8C File Offset: 0x00037F8C
		public static IObservable<T> ToObservable<T>(this IEnumerable<T> source, IScheduler scheduler)
		{
			return new ToObservableObservable<T>(source, scheduler);
		}

		// Token: 0x06000B23 RID: 2851 RVA: 0x00039B95 File Offset: 0x00037F95
		public static IObservable<TResult> Cast<T, TResult>(this IObservable<T> source)
		{
			return new CastObservable<T, TResult>(source);
		}

		// Token: 0x06000B24 RID: 2852 RVA: 0x00039B9D File Offset: 0x00037F9D
		public static IObservable<TResult> Cast<T, TResult>(this IObservable<T> source, TResult witness)
		{
			return new CastObservable<T, TResult>(source);
		}

		// Token: 0x06000B25 RID: 2853 RVA: 0x00039BA5 File Offset: 0x00037FA5
		public static IObservable<TResult> OfType<T, TResult>(this IObservable<T> source)
		{
			return new OfTypeObservable<T, TResult>(source);
		}

		// Token: 0x06000B26 RID: 2854 RVA: 0x00039BAD File Offset: 0x00037FAD
		public static IObservable<TResult> OfType<T, TResult>(this IObservable<T> source, TResult witness)
		{
			return new OfTypeObservable<T, TResult>(source);
		}

		// Token: 0x06000B27 RID: 2855 RVA: 0x00039BB5 File Offset: 0x00037FB5
		public static IObservable<Unit> AsUnitObservable<T>(this IObservable<T> source)
		{
			return new AsUnitObservableObservable<T>(source);
		}

		// Token: 0x06000B28 RID: 2856 RVA: 0x00039BBD File Offset: 0x00037FBD
		public static IObservable<Unit> AsSingleUnitObservable<T>(this IObservable<T> source)
		{
			return new AsSingleUnitObservableObservable<T>(source);
		}

		// Token: 0x06000B29 RID: 2857 RVA: 0x00039BC5 File Offset: 0x00037FC5
		public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T>(subscribe);
		}

		// Token: 0x06000B2A RID: 2858 RVA: 0x00039BDE File Offset: 0x00037FDE
		public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T>(subscribe, isRequiredSubscribeOnCurrentThread);
		}

		// Token: 0x06000B2B RID: 2859 RVA: 0x00039BF8 File Offset: 0x00037FF8
		public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T, TState>(state, subscribe);
		}

		// Token: 0x06000B2C RID: 2860 RVA: 0x00039C12 File Offset: 0x00038012
		public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T, TState>(state, subscribe, isRequiredSubscribeOnCurrentThread);
		}

		// Token: 0x06000B2D RID: 2861 RVA: 0x00039C2D File Offset: 0x0003802D
		public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateSafeObservable<T>(subscribe);
		}

		// Token: 0x06000B2E RID: 2862 RVA: 0x00039C46 File Offset: 0x00038046
		public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateSafeObservable<T>(subscribe, isRequiredSubscribeOnCurrentThread);
		}

		// Token: 0x06000B2F RID: 2863 RVA: 0x00039C60 File Offset: 0x00038060
		public static IObservable<T> Empty<T>()
		{
			return Observable.Empty<T>(Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		// Token: 0x06000B30 RID: 2864 RVA: 0x00039C6C File Offset: 0x0003806C
		public static IObservable<T> Empty<T>(IScheduler scheduler)
		{
			if (scheduler == Scheduler.Immediate)
			{
				return ImmutableEmptyObservable<T>.Instance;
			}
			return new EmptyObservable<T>(scheduler);
		}

		// Token: 0x06000B31 RID: 2865 RVA: 0x00039C85 File Offset: 0x00038085
		public static IObservable<T> Empty<T>(T witness)
		{
			return Observable.Empty<T>(Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		// Token: 0x06000B32 RID: 2866 RVA: 0x00039C91 File Offset: 0x00038091
		public static IObservable<T> Empty<T>(IScheduler scheduler, T witness)
		{
			return Observable.Empty<T>(scheduler);
		}

		// Token: 0x06000B33 RID: 2867 RVA: 0x00039C99 File Offset: 0x00038099
		public static IObservable<T> Never<T>()
		{
			return ImmutableNeverObservable<T>.Instance;
		}

		// Token: 0x06000B34 RID: 2868 RVA: 0x00039CA0 File Offset: 0x000380A0
		public static IObservable<T> Never<T>(T witness)
		{
			return ImmutableNeverObservable<T>.Instance;
		}

		// Token: 0x06000B35 RID: 2869 RVA: 0x00039CA7 File Offset: 0x000380A7
		public static IObservable<T> Return<T>(T value)
		{
			return Observable.Return<T>(value, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		// Token: 0x06000B36 RID: 2870 RVA: 0x00039CB4 File Offset: 0x000380B4
		public static IObservable<T> Return<T>(T value, IScheduler scheduler)
		{
			if (scheduler == Scheduler.Immediate)
			{
				return new ImmediateReturnObservable<T>(value);
			}
			return new ReturnObservable<T>(value, scheduler);
		}

		// Token: 0x06000B37 RID: 2871 RVA: 0x00039CCF File Offset: 0x000380CF
		public static IObservable<Unit> Return(Unit value)
		{
			return ImmutableReturnUnitObservable.Instance;
		}

		// Token: 0x06000B38 RID: 2872 RVA: 0x00039CD8 File Offset: 0x000380D8
		public static IObservable<bool> Return(bool value)
		{
			IObservable<bool> result;
			if (value)
			{
				IObservable<bool> instance = ImmutableReturnTrueObservable.Instance;
				result = instance;
			}
			else
			{
				result = ImmutableReturnFalseObservable.Instance;
			}
			return result;
		}

		// Token: 0x06000B39 RID: 2873 RVA: 0x00039CFC File Offset: 0x000380FC
		public static IObservable<Unit> ReturnUnit()
		{
			return ImmutableReturnUnitObservable.Instance;
		}

		// Token: 0x06000B3A RID: 2874 RVA: 0x00039D03 File Offset: 0x00038103
		public static IObservable<T> Throw<T>(Exception error)
		{
			return Observable.Throw<T>(error, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		// Token: 0x06000B3B RID: 2875 RVA: 0x00039D10 File Offset: 0x00038110
		public static IObservable<T> Throw<T>(Exception error, T witness)
		{
			return Observable.Throw<T>(error, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		// Token: 0x06000B3C RID: 2876 RVA: 0x00039D1D File Offset: 0x0003811D
		public static IObservable<T> Throw<T>(Exception error, IScheduler scheduler)
		{
			return new ThrowObservable<T>(error, scheduler);
		}

		// Token: 0x06000B3D RID: 2877 RVA: 0x00039D26 File Offset: 0x00038126
		public static IObservable<T> Throw<T>(Exception error, IScheduler scheduler, T witness)
		{
			return Observable.Throw<T>(error, scheduler);
		}

		// Token: 0x06000B3E RID: 2878 RVA: 0x00039D2F File Offset: 0x0003812F
		public static IObservable<int> Range(int start, int count)
		{
			return Observable.Range(start, count, Scheduler.DefaultSchedulers.Iteration);
		}

		// Token: 0x06000B3F RID: 2879 RVA: 0x00039D3D File Offset: 0x0003813D
		public static IObservable<int> Range(int start, int count, IScheduler scheduler)
		{
			return new RangeObservable(start, count, scheduler);
		}

		// Token: 0x06000B40 RID: 2880 RVA: 0x00039D47 File Offset: 0x00038147
		public static IObservable<T> Repeat<T>(T value)
		{
			return Observable.Repeat<T>(value, Scheduler.DefaultSchedulers.Iteration);
		}

		// Token: 0x06000B41 RID: 2881 RVA: 0x00039D54 File Offset: 0x00038154
		public static IObservable<T> Repeat<T>(T value, IScheduler scheduler)
		{
			if (scheduler == null)
			{
				throw new ArgumentNullException("scheduler");
			}
			return new RepeatObservable<T>(value, null, scheduler);
		}

		// Token: 0x06000B42 RID: 2882 RVA: 0x00039D82 File Offset: 0x00038182
		public static IObservable<T> Repeat<T>(T value, int repeatCount)
		{
			return Observable.Repeat<T>(value, repeatCount, Scheduler.DefaultSchedulers.Iteration);
		}

		// Token: 0x06000B43 RID: 2883 RVA: 0x00039D90 File Offset: 0x00038190
		public static IObservable<T> Repeat<T>(T value, int repeatCount, IScheduler scheduler)
		{
			if (repeatCount < 0)
			{
				throw new ArgumentOutOfRangeException("repeatCount");
			}
			if (scheduler == null)
			{
				throw new ArgumentNullException("scheduler");
			}
			return new RepeatObservable<T>(value, new int?(repeatCount), scheduler);
		}

		// Token: 0x06000B44 RID: 2884 RVA: 0x00039DC2 File Offset: 0x000381C2
		public static IObservable<T> Repeat<T>(this IObservable<T> source)
		{
			return Observable.RepeatInfinite<T>(source).Concat<T>();
		}

		// Token: 0x06000B45 RID: 2885 RVA: 0x00039DD0 File Offset: 0x000381D0
		private static IEnumerable<IObservable<T>> RepeatInfinite<T>(IObservable<T> source)
		{
			for (;;)
			{
				yield return source;
			}
			yield break;
		}

		// Token: 0x06000B46 RID: 2886 RVA: 0x00039DF3 File Offset: 0x000381F3
		public static IObservable<T> RepeatSafe<T>(this IObservable<T> source)
		{
			return new RepeatSafeObservable<T>(Observable.RepeatInfinite<T>(source), source.IsRequiredSubscribeOnCurrentThread<T>());
		}

		// Token: 0x06000B47 RID: 2887 RVA: 0x00039E06 File Offset: 0x00038206
		public static IObservable<T> Defer<T>(Func<IObservable<T>> observableFactory)
		{
			return new DeferObservable<T>(observableFactory);
		}

		// Token: 0x06000B48 RID: 2888 RVA: 0x00039E10 File Offset: 0x00038210
		public static IObservable<T> Start<T>(Func<T> function)
		{
			return new StartObservable<T>(function, null, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		// Token: 0x06000B49 RID: 2889 RVA: 0x00039E31 File Offset: 0x00038231
		public static IObservable<T> Start<T>(Func<T> function, TimeSpan timeSpan)
		{
			return new StartObservable<T>(function, new TimeSpan?(timeSpan), Scheduler.DefaultSchedulers.AsyncConversions);
		}

		// Token: 0x06000B4A RID: 2890 RVA: 0x00039E44 File Offset: 0x00038244
		public static IObservable<T> Start<T>(Func<T> function, IScheduler scheduler)
		{
			return new StartObservable<T>(function, null, scheduler);
		}

		// Token: 0x06000B4B RID: 2891 RVA: 0x00039E61 File Offset: 0x00038261
		public static IObservable<T> Start<T>(Func<T> function, TimeSpan timeSpan, IScheduler scheduler)
		{
			return new StartObservable<T>(function, new TimeSpan?(timeSpan), scheduler);
		}

		// Token: 0x06000B4C RID: 2892 RVA: 0x00039E70 File Offset: 0x00038270
		public static IObservable<Unit> Start(Action action)
		{
			return new StartObservable<Unit>(action, null, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		// Token: 0x06000B4D RID: 2893 RVA: 0x00039E91 File Offset: 0x00038291
		public static IObservable<Unit> Start(Action action, TimeSpan timeSpan)
		{
			return new StartObservable<Unit>(action, new TimeSpan?(timeSpan), Scheduler.DefaultSchedulers.AsyncConversions);
		}

		// Token: 0x06000B4E RID: 2894 RVA: 0x00039EA4 File Offset: 0x000382A4
		public static IObservable<Unit> Start(Action action, IScheduler scheduler)
		{
			return new StartObservable<Unit>(action, null, scheduler);
		}

		// Token: 0x06000B4F RID: 2895 RVA: 0x00039EC1 File Offset: 0x000382C1
		public static IObservable<Unit> Start(Action action, TimeSpan timeSpan, IScheduler scheduler)
		{
			return new StartObservable<Unit>(action, new TimeSpan?(timeSpan), scheduler);
		}

		// Token: 0x06000B50 RID: 2896 RVA: 0x00039ED0 File Offset: 0x000382D0
		public static Func<IObservable<T>> ToAsync<T>(Func<T> function)
		{
			return Observable.ToAsync<T>(function, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		// Token: 0x06000B51 RID: 2897 RVA: 0x00039EE0 File Offset: 0x000382E0
		public static Func<IObservable<T>> ToAsync<T>(Func<T> function, IScheduler scheduler)
		{
			return delegate()
			{
				AsyncSubject<T> subject = new AsyncSubject<T>();
				scheduler.Schedule(delegate()
				{
					T value = default(T);
					try
					{
						value = function();
					}
					catch (Exception error)
					{
						subject.OnError(error);
						return;
					}
					subject.OnNext(value);
					subject.OnCompleted();
				});
				return subject.AsObservable<T>();
			};
		}

		// Token: 0x06000B52 RID: 2898 RVA: 0x00039F0D File Offset: 0x0003830D
		public static Func<IObservable<Unit>> ToAsync(Action action)
		{
			return Observable.ToAsync(action, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		// Token: 0x06000B53 RID: 2899 RVA: 0x00039F1C File Offset: 0x0003831C
		public static Func<IObservable<Unit>> ToAsync(Action action, IScheduler scheduler)
		{
			return delegate()
			{
				AsyncSubject<Unit> subject = new AsyncSubject<Unit>();
				scheduler.Schedule(delegate()
				{
					try
					{
						action();
					}
					catch (Exception error)
					{
						subject.OnError(error);
						return;
					}
					subject.OnNext(Unit.Default);
					subject.OnCompleted();
				});
				return subject.AsObservable<Unit>();
			};
		}

		// Token: 0x06000B54 RID: 2900 RVA: 0x00039F49 File Offset: 0x00038349
		public static IObservable<T> Finally<T>(this IObservable<T> source, Action finallyAction)
		{
			return new FinallyObservable<T>(source, finallyAction);
		}

		// Token: 0x06000B55 RID: 2901 RVA: 0x00039F52 File Offset: 0x00038352
		public static IObservable<T> Catch<T, TException>(this IObservable<T> source, Func<TException, IObservable<T>> errorHandler) where TException : Exception
		{
			return new CatchObservable<T, TException>(source, errorHandler);
		}

		// Token: 0x06000B56 RID: 2902 RVA: 0x00039F5B File Offset: 0x0003835B
		public static IObservable<T> Catch<T>(this IEnumerable<IObservable<T>> sources)
		{
			return new CatchObservable<T>(sources);
		}

		// Token: 0x06000B57 RID: 2903 RVA: 0x00039F63 File Offset: 0x00038363
		public static IObservable<T> CatchIgnore<T>(this IObservable<T> source)
		{
			return source.Catch(new Func<Exception, IObservable<T>>(Stubs.CatchIgnore<T>));
		}

		// Token: 0x06000B58 RID: 2904 RVA: 0x00039F78 File Offset: 0x00038378
		public static IObservable<T> CatchIgnore<T, TException>(this IObservable<T> source, Action<TException> errorAction) where TException : Exception
		{
			return source.Catch(delegate(TException ex)
			{
				errorAction(ex);
				return Observable.Empty<T>();
			});
		}

		// Token: 0x06000B59 RID: 2905 RVA: 0x00039FA6 File Offset: 0x000383A6
		public static IObservable<T> Retry<T>(this IObservable<T> source)
		{
			return Observable.RepeatInfinite<T>(source).Catch<T>();
		}

		// Token: 0x06000B5A RID: 2906 RVA: 0x00039FB3 File Offset: 0x000383B3
		public static IObservable<T> Retry<T>(this IObservable<T> source, int retryCount)
		{
			return Enumerable.Repeat<IObservable<T>>(source, retryCount).Catch<T>();
		}

		// Token: 0x06000B5B RID: 2907 RVA: 0x00039FC4 File Offset: 0x000383C4
		public static IObservable<T> OnErrorRetry<T>(this IObservable<T> source)
		{
			return source.Retry<T>();
		}

		// Token: 0x06000B5C RID: 2908 RVA: 0x00039FD9 File Offset: 0x000383D9
		public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError) where TException : Exception
		{
			return source.OnErrorRetry(onError, TimeSpan.Zero);
		}

		// Token: 0x06000B5D RID: 2909 RVA: 0x00039FE7 File Offset: 0x000383E7
		public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, TimeSpan delay) where TException : Exception
		{
			return source.OnErrorRetry(onError, int.MaxValue, delay);
		}

		// Token: 0x06000B5E RID: 2910 RVA: 0x00039FF6 File Offset: 0x000383F6
		public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, int retryCount) where TException : Exception
		{
			return source.OnErrorRetry(onError, retryCount, TimeSpan.Zero);
		}

		// Token: 0x06000B5F RID: 2911 RVA: 0x0003A005 File Offset: 0x00038405
		public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, int retryCount, TimeSpan delay) where TException : Exception
		{
			return source.OnErrorRetry(onError, retryCount, delay, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B60 RID: 2912 RVA: 0x0003A018 File Offset: 0x00038418
		public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, int retryCount, TimeSpan delay, IScheduler delayScheduler) where TException : Exception
		{
			return Observable.Defer<T>(delegate
			{
				TimeSpan dueTime = (delay.Ticks >= 0L) ? delay : TimeSpan.Zero;
				int count = 0;
				IObservable<T> self = null;
				self = source.Catch(delegate(TException ex)
				{
					onError(ex);
					return (++count >= retryCount) ? Observable.Throw<T>(ex) : ((!(dueTime == TimeSpan.Zero)) ? self.DelaySubscription(dueTime, delayScheduler).SubscribeOn(Scheduler.CurrentThread) : self.SubscribeOn(Scheduler.CurrentThread));
				});
				return self;
			});
		}

		// Token: 0x06000B61 RID: 2913 RVA: 0x0003A062 File Offset: 0x00038462
		public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler) where TEventArgs : EventArgs
		{
			return new FromEventPatternObservable<TDelegate, TEventArgs>(conversion, addHandler, removeHandler);
		}

		// Token: 0x06000B62 RID: 2914 RVA: 0x0003A06C File Offset: 0x0003846C
		public static IObservable<Unit> FromEvent<TDelegate>(Func<Action, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler)
		{
			return new FromEventObservable<TDelegate>(conversion, addHandler, removeHandler);
		}

		// Token: 0x06000B63 RID: 2915 RVA: 0x0003A076 File Offset: 0x00038476
		public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler)
		{
			return new FromEventObservable<TDelegate, TEventArgs>(conversion, addHandler, removeHandler);
		}

		// Token: 0x06000B64 RID: 2916 RVA: 0x0003A080 File Offset: 0x00038480
		public static IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler)
		{
			return new FromEventObservable(addHandler, removeHandler);
		}

		// Token: 0x06000B65 RID: 2917 RVA: 0x0003A089 File Offset: 0x00038489
		public static IObservable<T> FromEvent<T>(Action<Action<T>> addHandler, Action<Action<T>> removeHandler)
		{
			return new FromEventObservable_<T>(addHandler, removeHandler);
		}

		// Token: 0x06000B66 RID: 2918 RVA: 0x0003A094 File Offset: 0x00038494
		public static Func<IObservable<TResult>> FromAsyncPattern<TResult>(Func<AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)
		{
			return delegate()
			{
				AsyncSubject<TResult> subject = new AsyncSubject<TResult>();
				try
				{
					begin(delegate(IAsyncResult iar)
					{
						TResult value;
						try
						{
							value = end(iar);
						}
						catch (Exception error2)
						{
							subject.OnError(error2);
							return;
						}
						subject.OnNext(value);
						subject.OnCompleted();
					}, null);
				}
				catch (Exception error)
				{
					return Observable.Throw<TResult>(error, Scheduler.DefaultSchedulers.AsyncConversions);
				}
				return subject.AsObservable<TResult>();
			};
		}

		// Token: 0x06000B67 RID: 2919 RVA: 0x0003A0C4 File Offset: 0x000384C4
		public static Func<T1, IObservable<TResult>> FromAsyncPattern<T1, TResult>(Func<T1, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)
		{
			return delegate(T1 x)
			{
				AsyncSubject<TResult> subject = new AsyncSubject<TResult>();
				try
				{
					begin(x, delegate(IAsyncResult iar)
					{
						TResult value;
						try
						{
							value = end(iar);
						}
						catch (Exception error2)
						{
							subject.OnError(error2);
							return;
						}
						subject.OnNext(value);
						subject.OnCompleted();
					}, null);
				}
				catch (Exception error)
				{
					return Observable.Throw<TResult>(error, Scheduler.DefaultSchedulers.AsyncConversions);
				}
				return subject.AsObservable<TResult>();
			};
		}

		// Token: 0x06000B68 RID: 2920 RVA: 0x0003A0F4 File Offset: 0x000384F4
		public static Func<T1, T2, IObservable<TResult>> FromAsyncPattern<T1, T2, TResult>(Func<T1, T2, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)
		{
			return delegate(T1 x, T2 y)
			{
				AsyncSubject<TResult> subject = new AsyncSubject<TResult>();
				try
				{
					begin(x, y, delegate(IAsyncResult iar)
					{
						TResult value;
						try
						{
							value = end(iar);
						}
						catch (Exception error2)
						{
							subject.OnError(error2);
							return;
						}
						subject.OnNext(value);
						subject.OnCompleted();
					}, null);
				}
				catch (Exception error)
				{
					return Observable.Throw<TResult>(error, Scheduler.DefaultSchedulers.AsyncConversions);
				}
				return subject.AsObservable<TResult>();
			};
		}

		// Token: 0x06000B69 RID: 2921 RVA: 0x0003A124 File Offset: 0x00038524
		public static Func<IObservable<Unit>> FromAsyncPattern(Func<AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)
		{
			return Observable.FromAsyncPattern<Unit>(begin, delegate(IAsyncResult iar)
			{
				end(iar);
				return Unit.Default;
			});
		}

		// Token: 0x06000B6A RID: 2922 RVA: 0x0003A150 File Offset: 0x00038550
		public static Func<T1, IObservable<Unit>> FromAsyncPattern<T1>(Func<T1, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)
		{
			return Observable.FromAsyncPattern<T1, Unit>(begin, delegate(IAsyncResult iar)
			{
				end(iar);
				return Unit.Default;
			});
		}

		// Token: 0x06000B6B RID: 2923 RVA: 0x0003A17C File Offset: 0x0003857C
		public static Func<T1, T2, IObservable<Unit>> FromAsyncPattern<T1, T2>(Func<T1, T2, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)
		{
			return Observable.FromAsyncPattern<T1, T2, Unit>(begin, delegate(IAsyncResult iar)
			{
				end(iar);
				return Unit.Default;
			});
		}

		// Token: 0x06000B6C RID: 2924 RVA: 0x0003A1A8 File Offset: 0x000385A8
		public static IObservable<T> Take<T>(this IObservable<T> source, int count)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			if (count == 0)
			{
				return Observable.Empty<T>();
			}
			TakeObservable<T> takeObservable = source as TakeObservable<T>;
			if (takeObservable != null && takeObservable.scheduler == null)
			{
				return takeObservable.Combine(count);
			}
			return new TakeObservable<T>(source, count);
		}

		// Token: 0x06000B6D RID: 2925 RVA: 0x0003A20B File Offset: 0x0003860B
		public static IObservable<T> Take<T>(this IObservable<T> source, TimeSpan duration)
		{
			return source.Take(duration, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B6E RID: 2926 RVA: 0x0003A21C File Offset: 0x0003861C
		public static IObservable<T> Take<T>(this IObservable<T> source, TimeSpan duration, IScheduler scheduler)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (scheduler == null)
			{
				throw new ArgumentNullException("scheduler");
			}
			TakeObservable<T> takeObservable = source as TakeObservable<T>;
			if (takeObservable != null && takeObservable.scheduler == scheduler)
			{
				return takeObservable.Combine(duration);
			}
			return new TakeObservable<T>(source, duration, scheduler);
		}

		// Token: 0x06000B6F RID: 2927 RVA: 0x0003A274 File Offset: 0x00038674
		public static IObservable<T> TakeWhile<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new TakeWhileObservable<T>(source, predicate);
		}

		// Token: 0x06000B70 RID: 2928 RVA: 0x0003A27D File Offset: 0x0003867D
		public static IObservable<T> TakeWhile<T>(this IObservable<T> source, Func<T, int, bool> predicate)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			return new TakeWhileObservable<T>(source, predicate);
		}

		// Token: 0x06000B71 RID: 2929 RVA: 0x0003A2A8 File Offset: 0x000386A8
		public static IObservable<T> TakeUntil<T, TOther>(this IObservable<T> source, IObservable<TOther> other)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (other == null)
			{
				throw new ArgumentNullException("other");
			}
			return new TakeUntilObservable<T, TOther>(source, other);
		}

		// Token: 0x06000B72 RID: 2930 RVA: 0x0003A2D3 File Offset: 0x000386D3
		public static IObservable<T> TakeLast<T>(this IObservable<T> source, int count)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			return new TakeLastObservable<T>(source, count);
		}

		// Token: 0x06000B73 RID: 2931 RVA: 0x0003A2FF File Offset: 0x000386FF
		public static IObservable<T> TakeLast<T>(this IObservable<T> source, TimeSpan duration)
		{
			return source.TakeLast(duration, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B74 RID: 2932 RVA: 0x0003A30D File Offset: 0x0003870D
		public static IObservable<T> TakeLast<T>(this IObservable<T> source, TimeSpan duration, IScheduler scheduler)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new TakeLastObservable<T>(source, duration, scheduler);
		}

		// Token: 0x06000B75 RID: 2933 RVA: 0x0003A328 File Offset: 0x00038728
		public static IObservable<T> Skip<T>(this IObservable<T> source, int count)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			SkipObservable<T> skipObservable = source as SkipObservable<T>;
			if (skipObservable != null && skipObservable.scheduler == null)
			{
				return skipObservable.Combine(count);
			}
			return new SkipObservable<T>(source, count);
		}

		// Token: 0x06000B76 RID: 2934 RVA: 0x0003A37F File Offset: 0x0003877F
		public static IObservable<T> Skip<T>(this IObservable<T> source, TimeSpan duration)
		{
			return source.Skip(duration, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B77 RID: 2935 RVA: 0x0003A390 File Offset: 0x00038790
		public static IObservable<T> Skip<T>(this IObservable<T> source, TimeSpan duration, IScheduler scheduler)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (scheduler == null)
			{
				throw new ArgumentNullException("scheduler");
			}
			SkipObservable<T> skipObservable = source as SkipObservable<T>;
			if (skipObservable != null && skipObservable.scheduler == scheduler)
			{
				return skipObservable.Combine(duration);
			}
			return new SkipObservable<T>(source, duration, scheduler);
		}

		// Token: 0x06000B78 RID: 2936 RVA: 0x0003A3E8 File Offset: 0x000387E8
		public static IObservable<T> SkipWhile<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new SkipWhileObservable<T>(source, predicate);
		}

		// Token: 0x06000B79 RID: 2937 RVA: 0x0003A3F1 File Offset: 0x000387F1
		public static IObservable<T> SkipWhile<T>(this IObservable<T> source, Func<T, int, bool> predicate)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			return new SkipWhileObservable<T>(source, predicate);
		}

		// Token: 0x06000B7A RID: 2938 RVA: 0x0003A41C File Offset: 0x0003881C
		public static IObservable<T> SkipUntil<T, TOther>(this IObservable<T> source, IObservable<TOther> other)
		{
			return new SkipUntilObservable<T, TOther>(source, other);
		}

		// Token: 0x06000B7B RID: 2939 RVA: 0x0003A425 File Offset: 0x00038825
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, int count)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (count <= 0)
			{
				throw new ArgumentOutOfRangeException("count <= 0");
			}
			return new BufferObservable<T>(source, count, 0);
		}

		// Token: 0x06000B7C RID: 2940 RVA: 0x0003A452 File Offset: 0x00038852
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, int count, int skip)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (count <= 0)
			{
				throw new ArgumentOutOfRangeException("count <= 0");
			}
			if (skip <= 0)
			{
				throw new ArgumentOutOfRangeException("skip <= 0");
			}
			return new BufferObservable<T>(source, count, skip);
		}

		// Token: 0x06000B7D RID: 2941 RVA: 0x0003A491 File Offset: 0x00038891
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, TimeSpan timeSpan)
		{
			return source.Buffer(timeSpan, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B7E RID: 2942 RVA: 0x0003A49F File Offset: 0x0003889F
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, TimeSpan timeSpan, IScheduler scheduler)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new BufferObservable<T>(source, timeSpan, timeSpan, scheduler);
		}

		// Token: 0x06000B7F RID: 2943 RVA: 0x0003A4BB File Offset: 0x000388BB
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, TimeSpan timeSpan, int count)
		{
			return source.Buffer(timeSpan, count, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B80 RID: 2944 RVA: 0x0003A4CA File Offset: 0x000388CA
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, TimeSpan timeSpan, int count, IScheduler scheduler)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (count <= 0)
			{
				throw new ArgumentOutOfRangeException("count <= 0");
			}
			return new BufferObservable<T>(source, timeSpan, count, scheduler);
		}

		// Token: 0x06000B81 RID: 2945 RVA: 0x0003A4F8 File Offset: 0x000388F8
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, TimeSpan timeSpan, TimeSpan timeShift)
		{
			return new BufferObservable<T>(source, timeSpan, timeShift, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B82 RID: 2946 RVA: 0x0003A507 File Offset: 0x00038907
		public static IObservable<IList<T>> Buffer<T>(this IObservable<T> source, TimeSpan timeSpan, TimeSpan timeShift, IScheduler scheduler)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new BufferObservable<T>(source, timeSpan, timeShift, scheduler);
		}

		// Token: 0x06000B83 RID: 2947 RVA: 0x0003A523 File Offset: 0x00038923
		public static IObservable<IList<T>> Buffer<T, TWindowBoundary>(this IObservable<T> source, IObservable<TWindowBoundary> windowBoundaries)
		{
			return new BufferObservable<T, TWindowBoundary>(source, windowBoundaries);
		}

		// Token: 0x06000B84 RID: 2948 RVA: 0x0003A52C File Offset: 0x0003892C
		public static IObservable<Pair<T>> Pairwise<T>(this IObservable<T> source)
		{
			return new PairwiseObservable<T>(source);
		}

		// Token: 0x06000B85 RID: 2949 RVA: 0x0003A534 File Offset: 0x00038934
		public static IObservable<TR> Pairwise<T, TR>(this IObservable<T> source, Func<T, T, TR> selector)
		{
			return new PairwiseObservable<T, TR>(source, selector);
		}

		// Token: 0x06000B86 RID: 2950 RVA: 0x0003A53D File Offset: 0x0003893D
		public static IObservable<T> Last<T>(this IObservable<T> source)
		{
			return new LastObservable<T>(source, false);
		}

		// Token: 0x06000B87 RID: 2951 RVA: 0x0003A546 File Offset: 0x00038946
		public static IObservable<T> Last<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new LastObservable<T>(source, predicate, false);
		}

		// Token: 0x06000B88 RID: 2952 RVA: 0x0003A550 File Offset: 0x00038950
		public static IObservable<T> LastOrDefault<T>(this IObservable<T> source)
		{
			return new LastObservable<T>(source, true);
		}

		// Token: 0x06000B89 RID: 2953 RVA: 0x0003A559 File Offset: 0x00038959
		public static IObservable<T> LastOrDefault<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new LastObservable<T>(source, predicate, true);
		}

		// Token: 0x06000B8A RID: 2954 RVA: 0x0003A563 File Offset: 0x00038963
		public static IObservable<T> First<T>(this IObservable<T> source)
		{
			return new FirstObservable<T>(source, false);
		}

		// Token: 0x06000B8B RID: 2955 RVA: 0x0003A56C File Offset: 0x0003896C
		public static IObservable<T> First<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new FirstObservable<T>(source, predicate, false);
		}

		// Token: 0x06000B8C RID: 2956 RVA: 0x0003A576 File Offset: 0x00038976
		public static IObservable<T> FirstOrDefault<T>(this IObservable<T> source)
		{
			return new FirstObservable<T>(source, true);
		}

		// Token: 0x06000B8D RID: 2957 RVA: 0x0003A57F File Offset: 0x0003897F
		public static IObservable<T> FirstOrDefault<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new FirstObservable<T>(source, predicate, true);
		}

		// Token: 0x06000B8E RID: 2958 RVA: 0x0003A589 File Offset: 0x00038989
		public static IObservable<T> Single<T>(this IObservable<T> source)
		{
			return new SingleObservable<T>(source, false);
		}

		// Token: 0x06000B8F RID: 2959 RVA: 0x0003A592 File Offset: 0x00038992
		public static IObservable<T> Single<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new SingleObservable<T>(source, predicate, false);
		}

		// Token: 0x06000B90 RID: 2960 RVA: 0x0003A59C File Offset: 0x0003899C
		public static IObservable<T> SingleOrDefault<T>(this IObservable<T> source)
		{
			return new SingleObservable<T>(source, true);
		}

		// Token: 0x06000B91 RID: 2961 RVA: 0x0003A5A5 File Offset: 0x000389A5
		public static IObservable<T> SingleOrDefault<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			return new SingleObservable<T>(source, predicate, true);
		}

		// Token: 0x06000B92 RID: 2962 RVA: 0x0003A5AF File Offset: 0x000389AF
		public static IObservable<IGroupedObservable<TKey, T>> GroupBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector)
		{
			return source.GroupBy(keySelector, Stubs<T>.Identity);
		}

		// Token: 0x06000B93 RID: 2963 RVA: 0x0003A5BD File Offset: 0x000389BD
		public static IObservable<IGroupedObservable<TKey, T>> GroupBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			return source.GroupBy(keySelector, Stubs<T>.Identity, comparer);
		}

		// Token: 0x06000B94 RID: 2964 RVA: 0x0003A5CC File Offset: 0x000389CC
		public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<T, TKey, TElement>(this IObservable<T> source, Func<T, TKey> keySelector, Func<T, TElement> elementSelector)
		{
			IEqualityComparer<TKey> @default = UnityEqualityComparer.GetDefault<TKey>();
			return source.GroupBy(keySelector, elementSelector, @default);
		}

		// Token: 0x06000B95 RID: 2965 RVA: 0x0003A5E8 File Offset: 0x000389E8
		public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<T, TKey, TElement>(this IObservable<T> source, Func<T, TKey> keySelector, Func<T, TElement> elementSelector, IEqualityComparer<TKey> comparer)
		{
			return new GroupByObservable<T, TKey, TElement>(source, keySelector, elementSelector, null, comparer);
		}

		// Token: 0x06000B96 RID: 2966 RVA: 0x0003A607 File Offset: 0x00038A07
		public static IObservable<IGroupedObservable<TKey, T>> GroupBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector, int capacity)
		{
			return source.GroupBy(keySelector, Stubs<T>.Identity, capacity);
		}

		// Token: 0x06000B97 RID: 2967 RVA: 0x0003A616 File Offset: 0x00038A16
		public static IObservable<IGroupedObservable<TKey, T>> GroupBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector, int capacity, IEqualityComparer<TKey> comparer)
		{
			return source.GroupBy(keySelector, Stubs<T>.Identity, capacity, comparer);
		}

		// Token: 0x06000B98 RID: 2968 RVA: 0x0003A628 File Offset: 0x00038A28
		public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<T, TKey, TElement>(this IObservable<T> source, Func<T, TKey> keySelector, Func<T, TElement> elementSelector, int capacity)
		{
			IEqualityComparer<TKey> @default = UnityEqualityComparer.GetDefault<TKey>();
			return source.GroupBy(keySelector, elementSelector, capacity, @default);
		}

		// Token: 0x06000B99 RID: 2969 RVA: 0x0003A645 File Offset: 0x00038A45
		public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<T, TKey, TElement>(this IObservable<T> source, Func<T, TKey> keySelector, Func<T, TElement> elementSelector, int capacity, IEqualityComparer<TKey> comparer)
		{
			return new GroupByObservable<T, TKey, TElement>(source, keySelector, elementSelector, new int?(capacity), comparer);
		}

		// Token: 0x06000B9A RID: 2970 RVA: 0x0003A657 File Offset: 0x00038A57
		public static IObservable<long> Interval(TimeSpan period)
		{
			return new TimerObservable(period, new TimeSpan?(period), Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B9B RID: 2971 RVA: 0x0003A66A File Offset: 0x00038A6A
		public static IObservable<long> Interval(TimeSpan period, IScheduler scheduler)
		{
			return new TimerObservable(period, new TimeSpan?(period), scheduler);
		}

		// Token: 0x06000B9C RID: 2972 RVA: 0x0003A67C File Offset: 0x00038A7C
		public static IObservable<long> Timer(TimeSpan dueTime)
		{
			return new TimerObservable(dueTime, null, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B9D RID: 2973 RVA: 0x0003A6A0 File Offset: 0x00038AA0
		public static IObservable<long> Timer(DateTimeOffset dueTime)
		{
			return new TimerObservable(dueTime, null, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B9E RID: 2974 RVA: 0x0003A6C1 File Offset: 0x00038AC1
		public static IObservable<long> Timer(TimeSpan dueTime, TimeSpan period)
		{
			return new TimerObservable(dueTime, new TimeSpan?(period), Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000B9F RID: 2975 RVA: 0x0003A6D4 File Offset: 0x00038AD4
		public static IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period)
		{
			return new TimerObservable(dueTime, new TimeSpan?(period), Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BA0 RID: 2976 RVA: 0x0003A6E8 File Offset: 0x00038AE8
		public static IObservable<long> Timer(TimeSpan dueTime, IScheduler scheduler)
		{
			return new TimerObservable(dueTime, null, scheduler);
		}

		// Token: 0x06000BA1 RID: 2977 RVA: 0x0003A708 File Offset: 0x00038B08
		public static IObservable<long> Timer(DateTimeOffset dueTime, IScheduler scheduler)
		{
			return new TimerObservable(dueTime, null, scheduler);
		}

		// Token: 0x06000BA2 RID: 2978 RVA: 0x0003A725 File Offset: 0x00038B25
		public static IObservable<long> Timer(TimeSpan dueTime, TimeSpan period, IScheduler scheduler)
		{
			return new TimerObservable(dueTime, new TimeSpan?(period), scheduler);
		}

		// Token: 0x06000BA3 RID: 2979 RVA: 0x0003A734 File Offset: 0x00038B34
		public static IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period, IScheduler scheduler)
		{
			return new TimerObservable(dueTime, new TimeSpan?(period), scheduler);
		}

		// Token: 0x06000BA4 RID: 2980 RVA: 0x0003A743 File Offset: 0x00038B43
		public static IObservable<Timestamped<T>> Timestamp<T>(this IObservable<T> source)
		{
			return source.Timestamp(Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BA5 RID: 2981 RVA: 0x0003A750 File Offset: 0x00038B50
		public static IObservable<Timestamped<T>> Timestamp<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return new TimestampObservable<T>(source, scheduler);
		}

		// Token: 0x06000BA6 RID: 2982 RVA: 0x0003A759 File Offset: 0x00038B59
		public static IObservable<TimeInterval<T>> TimeInterval<T>(this IObservable<T> source)
		{
			return source.TimeInterval(Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BA7 RID: 2983 RVA: 0x0003A766 File Offset: 0x00038B66
		public static IObservable<TimeInterval<T>> TimeInterval<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return new TimeIntervalObservable<T>(source, scheduler);
		}

		// Token: 0x06000BA8 RID: 2984 RVA: 0x0003A76F File Offset: 0x00038B6F
		public static IObservable<T> Delay<T>(this IObservable<T> source, TimeSpan dueTime)
		{
			return source.Delay(dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BA9 RID: 2985 RVA: 0x0003A77D File Offset: 0x00038B7D
		public static IObservable<T> Delay<T>(this IObservable<T> source, TimeSpan dueTime, IScheduler scheduler)
		{
			return new DelayObservable<T>(source, dueTime, scheduler);
		}

		// Token: 0x06000BAA RID: 2986 RVA: 0x0003A787 File Offset: 0x00038B87
		public static IObservable<T> Sample<T>(this IObservable<T> source, TimeSpan interval)
		{
			return source.Sample(interval, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BAB RID: 2987 RVA: 0x0003A795 File Offset: 0x00038B95
		public static IObservable<T> Sample<T>(this IObservable<T> source, TimeSpan interval, IScheduler scheduler)
		{
			return new SampleObservable<T>(source, interval, scheduler);
		}

		// Token: 0x06000BAC RID: 2988 RVA: 0x0003A79F File Offset: 0x00038B9F
		public static IObservable<T> Throttle<T>(this IObservable<T> source, TimeSpan dueTime)
		{
			return source.Throttle(dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BAD RID: 2989 RVA: 0x0003A7AD File Offset: 0x00038BAD
		public static IObservable<T> Throttle<T>(this IObservable<T> source, TimeSpan dueTime, IScheduler scheduler)
		{
			return new ThrottleObservable<T>(source, dueTime, scheduler);
		}

		// Token: 0x06000BAE RID: 2990 RVA: 0x0003A7B7 File Offset: 0x00038BB7
		public static IObservable<T> ThrottleFirst<T>(this IObservable<T> source, TimeSpan dueTime)
		{
			return source.ThrottleFirst(dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BAF RID: 2991 RVA: 0x0003A7C5 File Offset: 0x00038BC5
		public static IObservable<T> ThrottleFirst<T>(this IObservable<T> source, TimeSpan dueTime, IScheduler scheduler)
		{
			return new ThrottleFirstObservable<T>(source, dueTime, scheduler);
		}

		// Token: 0x06000BB0 RID: 2992 RVA: 0x0003A7CF File Offset: 0x00038BCF
		public static IObservable<T> Timeout<T>(this IObservable<T> source, TimeSpan dueTime)
		{
			return source.Timeout(dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BB1 RID: 2993 RVA: 0x0003A7DD File Offset: 0x00038BDD
		public static IObservable<T> Timeout<T>(this IObservable<T> source, TimeSpan dueTime, IScheduler scheduler)
		{
			return new TimeoutObservable<T>(source, dueTime, scheduler);
		}

		// Token: 0x06000BB2 RID: 2994 RVA: 0x0003A7E7 File Offset: 0x00038BE7
		public static IObservable<T> Timeout<T>(this IObservable<T> source, DateTimeOffset dueTime)
		{
			return source.Timeout(dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		// Token: 0x06000BB3 RID: 2995 RVA: 0x0003A7F5 File Offset: 0x00038BF5
		public static IObservable<T> Timeout<T>(this IObservable<T> source, DateTimeOffset dueTime, IScheduler scheduler)
		{
			return new TimeoutObservable<T>(source, dueTime, scheduler);
		}

		// Token: 0x06000BB4 RID: 2996 RVA: 0x0003A800 File Offset: 0x00038C00
		public static IObservable<TR> Select<T, TR>(this IObservable<T> source, Func<T, TR> selector)
		{
			WhereObservable<T> whereObservable = source as WhereObservable<T>;
			if (whereObservable != null)
			{
				return whereObservable.CombineSelector<TR>(selector);
			}
			return new SelectObservable<T, TR>(source, selector);
		}

		// Token: 0x06000BB5 RID: 2997 RVA: 0x0003A829 File Offset: 0x00038C29
		public static IObservable<TR> Select<T, TR>(this IObservable<T> source, Func<T, int, TR> selector)
		{
			return new SelectObservable<T, TR>(source, selector);
		}

		// Token: 0x06000BB6 RID: 2998 RVA: 0x0003A834 File Offset: 0x00038C34
		public static IObservable<T> Where<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			WhereObservable<T> whereObservable = source as WhereObservable<T>;
			if (whereObservable != null)
			{
				return whereObservable.CombinePredicate(predicate);
			}
			ISelect<T> select = source as ISelect<T>;
			if (select != null)
			{
				return select.CombinePredicate(predicate);
			}
			return new WhereObservable<T>(source, predicate);
		}

		// Token: 0x06000BB7 RID: 2999 RVA: 0x0003A872 File Offset: 0x00038C72
		public static IObservable<T> Where<T>(this IObservable<T> source, Func<T, int, bool> predicate)
		{
			return new WhereObservable<T>(source, predicate);
		}

		// Token: 0x06000BB8 RID: 3000 RVA: 0x0003A87C File Offset: 0x00038C7C
		public static IObservable<TR> ContinueWith<T, TR>(this IObservable<T> source, IObservable<TR> other)
		{
			return source.ContinueWith((T _) => other);
		}

		// Token: 0x06000BB9 RID: 3001 RVA: 0x0003A8A8 File Offset: 0x00038CA8
		public static IObservable<TR> ContinueWith<T, TR>(this IObservable<T> source, Func<T, IObservable<TR>> selector)
		{
			return new ContinueWithObservable<T, TR>(source, selector);
		}

		// Token: 0x06000BBA RID: 3002 RVA: 0x0003A8B4 File Offset: 0x00038CB4
		public static IObservable<TR> SelectMany<T, TR>(this IObservable<T> source, IObservable<TR> other)
		{
			return source.SelectMany((T _) => other);
		}

		// Token: 0x06000BBB RID: 3003 RVA: 0x0003A8E0 File Offset: 0x00038CE0
		public static IObservable<TR> SelectMany<T, TR>(this IObservable<T> source, Func<T, IObservable<TR>> selector)
		{
			return new SelectManyObservable<T, TR>(source, selector);
		}

		// Token: 0x06000BBC RID: 3004 RVA: 0x0003A8E9 File Offset: 0x00038CE9
		public static IObservable<TResult> SelectMany<T, TResult>(this IObservable<T> source, Func<T, int, IObservable<TResult>> selector)
		{
			return new SelectManyObservable<T, TResult>(source, selector);
		}

		// Token: 0x06000BBD RID: 3005 RVA: 0x0003A8F2 File Offset: 0x00038CF2
		public static IObservable<TR> SelectMany<T, TC, TR>(this IObservable<T> source, Func<T, IObservable<TC>> collectionSelector, Func<T, TC, TR> resultSelector)
		{
			return new SelectManyObservable<T, TC, TR>(source, collectionSelector, resultSelector);
		}

		// Token: 0x06000BBE RID: 3006 RVA: 0x0003A8FC File Offset: 0x00038CFC
		public static IObservable<TResult> SelectMany<T, TCollection, TResult>(this IObservable<T> source, Func<T, int, IObservable<TCollection>> collectionSelector, Func<T, int, TCollection, int, TResult> resultSelector)
		{
			return new SelectManyObservable<T, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		// Token: 0x06000BBF RID: 3007 RVA: 0x0003A906 File Offset: 0x00038D06
		public static IObservable<TResult> SelectMany<T, TResult>(this IObservable<T> source, Func<T, IEnumerable<TResult>> selector)
		{
			return new SelectManyObservable<T, TResult>(source, selector);
		}

		// Token: 0x06000BC0 RID: 3008 RVA: 0x0003A90F File Offset: 0x00038D0F
		public static IObservable<TResult> SelectMany<T, TResult>(this IObservable<T> source, Func<T, int, IEnumerable<TResult>> selector)
		{
			return new SelectManyObservable<T, TResult>(source, selector);
		}

		// Token: 0x06000BC1 RID: 3009 RVA: 0x0003A918 File Offset: 0x00038D18
		public static IObservable<TResult> SelectMany<T, TCollection, TResult>(this IObservable<T> source, Func<T, IEnumerable<TCollection>> collectionSelector, Func<T, TCollection, TResult> resultSelector)
		{
			return new SelectManyObservable<T, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		// Token: 0x06000BC2 RID: 3010 RVA: 0x0003A922 File Offset: 0x00038D22
		public static IObservable<TResult> SelectMany<T, TCollection, TResult>(this IObservable<T> source, Func<T, int, IEnumerable<TCollection>> collectionSelector, Func<T, int, TCollection, int, TResult> resultSelector)
		{
			return new SelectManyObservable<T, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		// Token: 0x06000BC3 RID: 3011 RVA: 0x0003A92C File Offset: 0x00038D2C
		public static IObservable<T[]> ToArray<T>(this IObservable<T> source)
		{
			return new ToArrayObservable<T>(source);
		}

		// Token: 0x06000BC4 RID: 3012 RVA: 0x0003A934 File Offset: 0x00038D34
		public static IObservable<IList<T>> ToList<T>(this IObservable<T> source)
		{
			return new ToListObservable<T>(source);
		}

		// Token: 0x06000BC5 RID: 3013 RVA: 0x0003A93C File Offset: 0x00038D3C
		public static IObservable<T> Do<T>(this IObservable<T> source, IObserver<T> observer)
		{
			return new DoObserverObservable<T>(source, observer);
		}

		// Token: 0x06000BC6 RID: 3014 RVA: 0x0003A945 File Offset: 0x00038D45
		public static IObservable<T> Do<T>(this IObservable<T> source, Action<T> onNext)
		{
			return new DoObservable<T>(source, onNext, Stubs.Throw, Stubs.Nop);
		}

		// Token: 0x06000BC7 RID: 3015 RVA: 0x0003A958 File Offset: 0x00038D58
		public static IObservable<T> Do<T>(this IObservable<T> source, Action<T> onNext, Action<Exception> onError)
		{
			return new DoObservable<T>(source, onNext, onError, Stubs.Nop);
		}

		// Token: 0x06000BC8 RID: 3016 RVA: 0x0003A967 File Offset: 0x00038D67
		public static IObservable<T> Do<T>(this IObservable<T> source, Action<T> onNext, Action onCompleted)
		{
			return new DoObservable<T>(source, onNext, Stubs.Throw, onCompleted);
		}

		// Token: 0x06000BC9 RID: 3017 RVA: 0x0003A976 File Offset: 0x00038D76
		public static IObservable<T> Do<T>(this IObservable<T> source, Action<T> onNext, Action<Exception> onError, Action onCompleted)
		{
			return new DoObservable<T>(source, onNext, onError, onCompleted);
		}

		// Token: 0x06000BCA RID: 3018 RVA: 0x0003A981 File Offset: 0x00038D81
		public static IObservable<T> DoOnError<T>(this IObservable<T> source, Action<Exception> onError)
		{
			return new DoOnErrorObservable<T>(source, onError);
		}

		// Token: 0x06000BCB RID: 3019 RVA: 0x0003A98A File Offset: 0x00038D8A
		public static IObservable<T> DoOnCompleted<T>(this IObservable<T> source, Action onCompleted)
		{
			return new DoOnCompletedObservable<T>(source, onCompleted);
		}

		// Token: 0x06000BCC RID: 3020 RVA: 0x0003A993 File Offset: 0x00038D93
		public static IObservable<T> DoOnTerminate<T>(this IObservable<T> source, Action onTerminate)
		{
			return new DoOnTerminateObservable<T>(source, onTerminate);
		}

		// Token: 0x06000BCD RID: 3021 RVA: 0x0003A99C File Offset: 0x00038D9C
		public static IObservable<T> DoOnSubscribe<T>(this IObservable<T> source, Action onSubscribe)
		{
			return new DoOnSubscribeObservable<T>(source, onSubscribe);
		}

		// Token: 0x06000BCE RID: 3022 RVA: 0x0003A9A5 File Offset: 0x00038DA5
		public static IObservable<T> DoOnCancel<T>(this IObservable<T> source, Action onCancel)
		{
			return new DoOnCancelObservable<T>(source, onCancel);
		}

		// Token: 0x06000BCF RID: 3023 RVA: 0x0003A9AE File Offset: 0x00038DAE
		public static IObservable<Notification<T>> Materialize<T>(this IObservable<T> source)
		{
			return new MaterializeObservable<T>(source);
		}

		// Token: 0x06000BD0 RID: 3024 RVA: 0x0003A9B6 File Offset: 0x00038DB6
		public static IObservable<T> Dematerialize<T>(this IObservable<Notification<T>> source)
		{
			return new DematerializeObservable<T>(source);
		}

		// Token: 0x06000BD1 RID: 3025 RVA: 0x0003A9C0 File Offset: 0x00038DC0
		public static IObservable<T> DefaultIfEmpty<T>(this IObservable<T> source)
		{
			return new DefaultIfEmptyObservable<T>(source, default(T));
		}

		// Token: 0x06000BD2 RID: 3026 RVA: 0x0003A9DC File Offset: 0x00038DDC
		public static IObservable<T> DefaultIfEmpty<T>(this IObservable<T> source, T defaultValue)
		{
			return new DefaultIfEmptyObservable<T>(source, defaultValue);
		}

		// Token: 0x06000BD3 RID: 3027 RVA: 0x0003A9E8 File Offset: 0x00038DE8
		public static IObservable<T> Distinct<T>(this IObservable<T> source)
		{
			IEqualityComparer<T> @default = UnityEqualityComparer.GetDefault<T>();
			return new DistinctObservable<T>(source, @default);
		}

		// Token: 0x06000BD4 RID: 3028 RVA: 0x0003AA02 File Offset: 0x00038E02
		public static IObservable<T> Distinct<T>(this IObservable<T> source, IEqualityComparer<T> comparer)
		{
			return new DistinctObservable<T>(source, comparer);
		}

		// Token: 0x06000BD5 RID: 3029 RVA: 0x0003AA0C File Offset: 0x00038E0C
		public static IObservable<T> Distinct<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector)
		{
			IEqualityComparer<TKey> @default = UnityEqualityComparer.GetDefault<TKey>();
			return new DistinctObservable<T, TKey>(source, keySelector, @default);
		}

		// Token: 0x06000BD6 RID: 3030 RVA: 0x0003AA27 File Offset: 0x00038E27
		public static IObservable<T> Distinct<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			return new DistinctObservable<T, TKey>(source, keySelector, comparer);
		}

		// Token: 0x06000BD7 RID: 3031 RVA: 0x0003AA34 File Offset: 0x00038E34
		public static IObservable<T> DistinctUntilChanged<T>(this IObservable<T> source)
		{
			IEqualityComparer<T> @default = UnityEqualityComparer.GetDefault<T>();
			return new DistinctUntilChangedObservable<T>(source, @default);
		}

		// Token: 0x06000BD8 RID: 3032 RVA: 0x0003AA4E File Offset: 0x00038E4E
		public static IObservable<T> DistinctUntilChanged<T>(this IObservable<T> source, IEqualityComparer<T> comparer)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new DistinctUntilChangedObservable<T>(source, comparer);
		}

		// Token: 0x06000BD9 RID: 3033 RVA: 0x0003AA68 File Offset: 0x00038E68
		public static IObservable<T> DistinctUntilChanged<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector)
		{
			IEqualityComparer<TKey> @default = UnityEqualityComparer.GetDefault<TKey>();
			return new DistinctUntilChangedObservable<T, TKey>(source, keySelector, @default);
		}

		// Token: 0x06000BDA RID: 3034 RVA: 0x0003AA83 File Offset: 0x00038E83
		public static IObservable<T> DistinctUntilChanged<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new DistinctUntilChangedObservable<T, TKey>(source, keySelector, comparer);
		}

		// Token: 0x06000BDB RID: 3035 RVA: 0x0003AA9E File Offset: 0x00038E9E
		public static IObservable<T> IgnoreElements<T>(this IObservable<T> source)
		{
			return new IgnoreElementsObservable<T>(source);
		}

		// Token: 0x06000BDC RID: 3036 RVA: 0x0003AAA6 File Offset: 0x00038EA6
		public static IObservable<Unit> ForEachAsync<T>(this IObservable<T> source, Action<T> onNext)
		{
			return new ForEachAsyncObservable<T>(source, onNext);
		}

		// Token: 0x06000BDD RID: 3037 RVA: 0x0003AAAF File Offset: 0x00038EAF
		public static IObservable<Unit> ForEachAsync<T>(this IObservable<T> source, Action<T, int> onNext)
		{
			return new ForEachAsyncObservable<T>(source, onNext);
		}

		// Token: 0x06000BDE RID: 3038 RVA: 0x0003AAB8 File Offset: 0x00038EB8
		public static IObservable<Unit> FromCoroutine(Func<IEnumerator> coroutine, bool publishEveryYield = false)
		{
			return Observable.FromCoroutine<Unit>((IObserver<Unit> observer, CancellationToken cancellationToken) => Observable.WrapEnumerator(coroutine(), observer, cancellationToken, publishEveryYield));
		}

		// Token: 0x06000BDF RID: 3039 RVA: 0x0003AAEC File Offset: 0x00038EEC
		public static IObservable<Unit> FromCoroutine(Func<CancellationToken, IEnumerator> coroutine, bool publishEveryYield = false)
		{
			return Observable.FromCoroutine<Unit>((IObserver<Unit> observer, CancellationToken cancellationToken) => Observable.WrapEnumerator(coroutine(cancellationToken), observer, cancellationToken, publishEveryYield));
		}

		// Token: 0x06000BE0 RID: 3040 RVA: 0x0003AB20 File Offset: 0x00038F20
		public static IObservable<Unit> FromMicroCoroutine(Func<IEnumerator> coroutine, bool publishEveryYield = false, FrameCountType frameCountType = FrameCountType.Update)
		{
			return Observable.FromMicroCoroutine<Unit>((IObserver<Unit> observer, CancellationToken cancellationToken) => Observable.WrapEnumerator(coroutine(), observer, cancellationToken, publishEveryYield), frameCountType);
		}

		// Token: 0x06000BE1 RID: 3041 RVA: 0x0003AB54 File Offset: 0x00038F54
		public static IObservable<Unit> FromMicroCoroutine(Func<CancellationToken, IEnumerator> coroutine, bool publishEveryYield = false, FrameCountType frameCountType = FrameCountType.Update)
		{
			return Observable.FromMicroCoroutine<Unit>((IObserver<Unit> observer, CancellationToken cancellationToken) => Observable.WrapEnumerator(coroutine(cancellationToken), observer, cancellationToken, publishEveryYield), frameCountType);
		}

		// Token: 0x06000BE2 RID: 3042 RVA: 0x0003AB88 File Offset: 0x00038F88
		private static IEnumerator WrapEnumerator(IEnumerator enumerator, IObserver<Unit> observer, CancellationToken cancellationToken, bool publishEveryYield)
		{
			bool hasNext = false;
			bool raisedError = false;
			ICustomYieldInstructionErrorHandler customHandler;
			for (;;)
			{
				try
				{
					hasNext = enumerator.MoveNext();
				}
				catch (Exception error)
				{
					try
					{
						raisedError = true;
						observer.OnError(error);
					}
					finally
					{
						IDisposable disposable = enumerator as IDisposable;
						if (disposable != null)
						{
							disposable.Dispose();
						}
					}
					yield break;
				}
				if (hasNext && publishEveryYield)
				{
					try
					{
						observer.OnNext(Unit.Default);
					}
					catch
					{
						IDisposable disposable2 = enumerator as IDisposable;
						if (disposable2 != null)
						{
							disposable2.Dispose();
						}
						throw;
					}
				}
				if (hasNext)
				{
					object current = enumerator.Current;
					customHandler = (current as ICustomYieldInstructionErrorHandler);
					if (customHandler != null && customHandler.IsReThrowOnError)
					{
						customHandler.ForceDisableRethrowOnError();
						yield return current;
						customHandler.ForceEnableRethrowOnError();
						if (customHandler.HasError)
						{
							break;
						}
					}
					else
					{
						yield return enumerator.Current;
					}
				}
				//if (!hasNext)
				//{
				//	goto IL_1DC;
				//}
				if (cancellationToken.IsCancellationRequested)
				{
					goto Block_9;
				}
			}
			try
			{
				raisedError = true;
				observer.OnError(customHandler.Error);
			}
			finally
			{
				IDisposable disposable3 = enumerator as IDisposable;
				if (disposable3 != null)
				{
					disposable3.Dispose();
				}
			}
			yield break;
			Block_9:
			try
			{
				IL_1DC:
				if (!raisedError && !cancellationToken.IsCancellationRequested)
				{
					observer.OnNext(Unit.Default);
					observer.OnCompleted();
				}
			}
			finally
			{
				IDisposable disposable4 = enumerator as IDisposable;
				if (disposable4 != null)
				{
					disposable4.Dispose();
				}
			}
			yield break;
		}

		// Token: 0x06000BE3 RID: 3043 RVA: 0x0003ABB8 File Offset: 0x00038FB8
		public static IObservable<T> FromCoroutineValue<T>(Func<IEnumerator> coroutine, bool nullAsNextUpdate = true)
		{
			return Observable.FromCoroutine<T>((IObserver<T> observer, CancellationToken cancellationToken) => Observable.WrapEnumeratorYieldValue<T>(coroutine(), observer, cancellationToken, nullAsNextUpdate));
		}

		// Token: 0x06000BE4 RID: 3044 RVA: 0x0003ABEC File Offset: 0x00038FEC
		public static IObservable<T> FromCoroutineValue<T>(Func<CancellationToken, IEnumerator> coroutine, bool nullAsNextUpdate = true)
		{
			return Observable.FromCoroutine<T>((IObserver<T> observer, CancellationToken cancellationToken) => Observable.WrapEnumeratorYieldValue<T>(coroutine(cancellationToken), observer, cancellationToken, nullAsNextUpdate));
		}

		// Token: 0x06000BE5 RID: 3045 RVA: 0x0003AC20 File Offset: 0x00039020
		private static IEnumerator WrapEnumeratorYieldValue<T>(IEnumerator enumerator, IObserver<T> observer, CancellationToken cancellationToken, bool nullAsNextUpdate)
		{
			bool hasNext = false;
			object current = null;
			bool raisedError = false;
			ICustomYieldInstructionErrorHandler customHandler;
			for (;;)
			{
				try
				{
					hasNext = enumerator.MoveNext();
					if (hasNext)
					{
						current = enumerator.Current;
					}
				}
				catch (Exception error)
				{
					try
					{
						raisedError = true;
						observer.OnError(error);
					}
					finally
					{
						IDisposable disposable = enumerator as IDisposable;
						if (disposable != null)
						{
							disposable.Dispose();
						}
					}
					yield break;
				}
				if (hasNext)
				{
					if (current != null && Observable.YieldInstructionTypes.Contains(current.GetType()))
					{
						yield return current;
					}
					else if (current is IEnumerator)
					{
						customHandler = (current as ICustomYieldInstructionErrorHandler);
						if (customHandler != null && customHandler.IsReThrowOnError)
						{
							customHandler.ForceDisableRethrowOnError();
							yield return current;
							customHandler.ForceEnableRethrowOnError();
							if (customHandler.HasError)
							{
								break;
							}
						}
						else
						{
							yield return current;
						}
					}
					else if (current == null && nullAsNextUpdate)
					{
						yield return null;
					}
					else
					{
						try
						{
							observer.OnNext((T)((object)current));
						}
						catch
						{
							IDisposable disposable2 = enumerator as IDisposable;
							if (disposable2 != null)
							{
								disposable2.Dispose();
							}
							throw;
						}
					}
				}
				//if (!hasNext)
				//{
				//	goto IL_276;
				//}
				if (cancellationToken.IsCancellationRequested)
				{
					goto Block_13;
				}
			}
			try
			{
				raisedError = true;
				observer.OnError(customHandler.Error);
			}
			finally
			{
				IDisposable disposable3 = enumerator as IDisposable;
				if (disposable3 != null)
				{
					disposable3.Dispose();
				}
			}
			yield break;
			Block_13:
			try
			{
				IL_276:
				if (!raisedError && !cancellationToken.IsCancellationRequested)
				{
					observer.OnCompleted();
				}
			}
			finally
			{
				IDisposable disposable4 = enumerator as IDisposable;
				if (disposable4 != null)
				{
					disposable4.Dispose();
				}
			}
			yield break;
		}

		// Token: 0x06000BE6 RID: 3046 RVA: 0x0003AC50 File Offset: 0x00039050
		public static IObservable<T> FromCoroutine<T>(Func<IObserver<T>, IEnumerator> coroutine)
		{
			return Observable.FromCoroutine<T>((IObserver<T> observer, CancellationToken cancellationToken) => Observable.WrapToCancellableEnumerator(coroutine(observer), cancellationToken));
		}

		// Token: 0x06000BE7 RID: 3047 RVA: 0x0003AC7C File Offset: 0x0003907C
		public static IObservable<T> FromMicroCoroutine<T>(Func<IObserver<T>, IEnumerator> coroutine, FrameCountType frameCountType = FrameCountType.Update)
		{
			return Observable.FromMicroCoroutine<T>((IObserver<T> observer, CancellationToken cancellationToken) => Observable.WrapToCancellableEnumerator(coroutine(observer), cancellationToken), frameCountType);
		}

		// Token: 0x06000BE8 RID: 3048 RVA: 0x0003ACA8 File Offset: 0x000390A8
		private static IEnumerator WrapToCancellableEnumerator(IEnumerator enumerator, CancellationToken cancellationToken)
		{
			bool hasNext = false;
			do
			{
				try
				{
					hasNext = enumerator.MoveNext();
				}
				catch
				{
					IDisposable disposable = enumerator as IDisposable;
					if (disposable != null)
					{
						disposable.Dispose();
					}
					yield break;
				}
				yield return enumerator.Current;
			}
			while (hasNext && !cancellationToken.IsCancellationRequested);
			IDisposable disposable2 = enumerator as IDisposable;
			if (disposable2 != null)
			{
				disposable2.Dispose();
			}
			yield break;
		}

		// Token: 0x06000BE9 RID: 3049 RVA: 0x0003ACCA File Offset: 0x000390CA
		public static IObservable<T> FromCoroutine<T>(Func<IObserver<T>, CancellationToken, IEnumerator> coroutine)
		{
			return new FromCoroutineObservable<T>(coroutine);
		}

		// Token: 0x06000BEA RID: 3050 RVA: 0x0003ACD2 File Offset: 0x000390D2
		public static IObservable<T> FromMicroCoroutine<T>(Func<IObserver<T>, CancellationToken, IEnumerator> coroutine, FrameCountType frameCountType = FrameCountType.Update)
		{
			return new FromMicroCoroutineObservable<T>(coroutine, frameCountType);
		}

		// Token: 0x06000BEB RID: 3051 RVA: 0x0003ACDC File Offset: 0x000390DC
		public static IObservable<Unit> SelectMany<T>(this IObservable<T> source, IEnumerator coroutine, bool publishEveryYield = false)
		{
			return source.SelectMany(Observable.FromCoroutine(() => coroutine, publishEveryYield));
		}

		// Token: 0x06000BEC RID: 3052 RVA: 0x0003AD10 File Offset: 0x00039110
		public static IObservable<Unit> SelectMany<T>(this IObservable<T> source, Func<IEnumerator> selector, bool publishEveryYield = false)
		{
			return source.SelectMany(Observable.FromCoroutine(() => selector(), publishEveryYield));
		}

		// Token: 0x06000BED RID: 3053 RVA: 0x0003AD44 File Offset: 0x00039144
		public static IObservable<Unit> SelectMany<T>(this IObservable<T> source, Func<T, IEnumerator> selector)
		{
			return source.SelectMany((T x) => Observable.FromCoroutine(() => selector(x), false));
		}

		// Token: 0x06000BEE RID: 3054 RVA: 0x0003AD70 File Offset: 0x00039170
		public static IObservable<Unit> ToObservable(this IEnumerator coroutine, bool publishEveryYield = false)
		{
			return Observable.FromCoroutine<Unit>((IObserver<Unit> observer, CancellationToken cancellationToken) => Observable.WrapEnumerator(coroutine, observer, cancellationToken, publishEveryYield));
		}

		// Token: 0x06000BEF RID: 3055 RVA: 0x0003ADA2 File Offset: 0x000391A2
		public static ObservableYieldInstruction<Unit> ToYieldInstruction(this IEnumerator coroutine)
		{
			return coroutine.ToObservable(false).ToYieldInstruction<Unit>();
		}

		// Token: 0x06000BF0 RID: 3056 RVA: 0x0003ADB0 File Offset: 0x000391B0
		public static ObservableYieldInstruction<Unit> ToYieldInstruction(this IEnumerator coroutine, bool throwOnError)
		{
			return coroutine.ToObservable(false).ToYieldInstruction(throwOnError);
		}

		// Token: 0x06000BF1 RID: 3057 RVA: 0x0003ADBF File Offset: 0x000391BF
		public static ObservableYieldInstruction<Unit> ToYieldInstruction(this IEnumerator coroutine, CancellationToken cancellationToken)
		{
			return coroutine.ToObservable(false).ToYieldInstruction(cancellationToken);
		}

		// Token: 0x06000BF2 RID: 3058 RVA: 0x0003ADCE File Offset: 0x000391CE
		public static ObservableYieldInstruction<Unit> ToYieldInstruction(this IEnumerator coroutine, bool throwOnError, CancellationToken cancellationToken)
		{
			return coroutine.ToObservable(false).ToYieldInstruction(throwOnError, cancellationToken);
		}

		// Token: 0x06000BF3 RID: 3059 RVA: 0x0003ADDE File Offset: 0x000391DE
		public static IObservable<long> EveryUpdate()
		{
			//if (Observable.callback0 == null)
			//{
			//	Observable.callback0 = new Func<IObserver<long>, CancellationToken, IEnumerator>(Observable.EveryCycleCore);
			//}
			//return Observable.FromMicroCoroutine<long>(Observable.callback0, FrameCountType.Update);
			return null;
		}

		// Token: 0x06000BF4 RID: 3060 RVA: 0x0003AE03 File Offset: 0x00039203
		public static IObservable<long> EveryFixedUpdate()
		{
			//if (Observable.callback1 == null)
			//{
			//	Observable.callback1 = new Func<IObserver<long>, CancellationToken, IEnumerator>(Observable.EveryCycleCore);
			//}
			//return Observable.FromMicroCoroutine<long>(Observable.callback1, FrameCountType.FixedUpdate);

			return null;
		}

		// Token: 0x06000BF5 RID: 3061 RVA: 0x0003AE28 File Offset: 0x00039228
		public static IObservable<long> EveryEndOfFrame()
		{
			//if (Observable.callback2 == null)
			//{
			//	Observable.callback2 = new Func<IObserver<long>, CancellationToken, IEnumerator>(Observable.EveryCycleCore);
			//}
			//return Observable.FromMicroCoroutine<long>(Observable.callback2, FrameCountType.EndOfFrame);
			return null;
		}

		// Token: 0x06000BF6 RID: 3062 RVA: 0x0003AE50 File Offset: 0x00039250
		private static IEnumerator EveryCycleCore(IObserver<long> observer, CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				yield break;
			}
			long count = 0L;
			for (;;)
			{
				yield return null;
				if (cancellationToken.IsCancellationRequested)
				{
					break;
				}
				long value;
				count = (value = count) + 1L;
				observer.OnNext(value);
			}
			yield break;
			yield break;
		}

		// Token: 0x06000BF7 RID: 3063 RVA: 0x0003AE72 File Offset: 0x00039272
		public static IObservable<long> EveryGameObjectUpdate()
		{
			return MainThreadDispatcher.UpdateAsObservable().Scan(-1L, (long x, Unit y) => x + 1L);
		}

		// Token: 0x06000BF8 RID: 3064 RVA: 0x0003AE9D File Offset: 0x0003929D
		public static IObservable<long> EveryLateUpdate()
		{
			return MainThreadDispatcher.LateUpdateAsObservable().Scan(-1L, (long x, Unit y) => x + 1L);
		}

		// Token: 0x06000BF9 RID: 3065 RVA: 0x0003AEC8 File Offset: 0x000392C8
		[Obsolete]
		public static IObservable<long> EveryAfterUpdate()
		{
			return Observable.FromCoroutine<long>((IObserver<long> observer, CancellationToken cancellationToken) => new Observable.EveryAfterUpdateInvoker(observer, cancellationToken));
		}

		// Token: 0x06000BFA RID: 3066 RVA: 0x0003AEEC File Offset: 0x000392EC
		public static IObservable<Unit> NextFrame(FrameCountType frameCountType = FrameCountType.Update)
		{
			//if (Observable.callback3 == null)
			//{
			//	Observable.callback3 = new Func<IObserver<Unit>, CancellationToken, IEnumerator>(Observable.NextFrameCore);
			//}
			//return Observable.FromMicroCoroutine<Unit>(Observable.callback3, frameCountType);
			return null;
		}

		// Token: 0x06000BFB RID: 3067 RVA: 0x0003AF14 File Offset: 0x00039314
		private static IEnumerator NextFrameCore(IObserver<Unit> observer, CancellationToken cancellation)
		{
			yield return null;
			if (!cancellation.IsCancellationRequested)
			{
				observer.OnNext(Unit.Default);
				observer.OnCompleted();
			}
			yield break;
		}

		// Token: 0x06000BFC RID: 3068 RVA: 0x0003AF36 File Offset: 0x00039336
		public static IObservable<long> IntervalFrame(int intervalFrameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			return Observable.TimerFrame(intervalFrameCount, intervalFrameCount, frameCountType);
		}

		// Token: 0x06000BFD RID: 3069 RVA: 0x0003AF40 File Offset: 0x00039340
		public static IObservable<long> TimerFrame(int dueTimeFrameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			return Observable.FromMicroCoroutine<long>((IObserver<long> observer, CancellationToken cancellation) => Observable.TimerFrameCore(observer, dueTimeFrameCount, cancellation), frameCountType);
		}

		// Token: 0x06000BFE RID: 3070 RVA: 0x0003AF6C File Offset: 0x0003936C
		public static IObservable<long> TimerFrame(int dueTimeFrameCount, int periodFrameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			return Observable.FromMicroCoroutine<long>((IObserver<long> observer, CancellationToken cancellation) => Observable.TimerFrameCore(observer, dueTimeFrameCount, periodFrameCount, cancellation), frameCountType);
		}

		// Token: 0x06000BFF RID: 3071 RVA: 0x0003AFA0 File Offset: 0x000393A0
		private static IEnumerator TimerFrameCore(IObserver<long> observer, int dueTimeFrameCount, CancellationToken cancel)
		{
			if (dueTimeFrameCount <= 0)
			{
				dueTimeFrameCount = 0;
			}
			int currentFrame = 0;
			while (!cancel.IsCancellationRequested)
			{
				int num;
				currentFrame = (num = currentFrame) + 1;
				if (num == dueTimeFrameCount)
				{
					observer.OnNext(0L);
					observer.OnCompleted();
					break;
				}
				yield return null;
			}
			yield break;
		}

		// Token: 0x06000C00 RID: 3072 RVA: 0x0003AFCC File Offset: 0x000393CC
		private static IEnumerator TimerFrameCore(IObserver<long> observer, int dueTimeFrameCount, int periodFrameCount, CancellationToken cancel)
		{
			if (dueTimeFrameCount <= 0)
			{
				dueTimeFrameCount = 0;
			}
			if (periodFrameCount <= 0)
			{
				periodFrameCount = 1;
			}
			long sendCount = 0L;
			int currentFrame = 0;
			while (!cancel.IsCancellationRequested)
			{
				int num;
				currentFrame = (num = currentFrame) + 1;
				if (num == dueTimeFrameCount)
				{
					long value;
					sendCount = (value = sendCount) + 1L;
					observer.OnNext(value);
					currentFrame = -1;
					break;
				}
				yield return null;
			}
			while (!cancel.IsCancellationRequested)
			{
				if (++currentFrame == periodFrameCount)
				{
					long value;
					sendCount = (value = sendCount) + 1L;
					observer.OnNext(value);
					currentFrame = 0;
				}
				yield return null;
			}
			yield break;
		}

		// Token: 0x06000C01 RID: 3073 RVA: 0x0003AFFC File Offset: 0x000393FC
		public static IObservable<T> DelayFrame<T>(this IObservable<T> source, int frameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			if (frameCount < 0)
			{
				throw new ArgumentOutOfRangeException("frameCount");
			}
			return new DelayFrameObservable<T>(source, frameCount, frameCountType);
		}

		// Token: 0x06000C02 RID: 3074 RVA: 0x0003B018 File Offset: 0x00039418
		public static IObservable<T> Sample<T, T2>(this IObservable<T> source, IObservable<T2> sampler)
		{
			return new SampleObservable<T, T2>(source, sampler);
		}

		// Token: 0x06000C03 RID: 3075 RVA: 0x0003B021 File Offset: 0x00039421
		public static IObservable<T> SampleFrame<T>(this IObservable<T> source, int frameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			if (frameCount < 0)
			{
				throw new ArgumentOutOfRangeException("frameCount");
			}
			return new SampleFrameObservable<T>(source, frameCount, frameCountType);
		}

		// Token: 0x06000C04 RID: 3076 RVA: 0x0003B03D File Offset: 0x0003943D
		public static IObservable<T> ThrottleFrame<T>(this IObservable<T> source, int frameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			if (frameCount < 0)
			{
				throw new ArgumentOutOfRangeException("frameCount");
			}
			return new ThrottleFrameObservable<T>(source, frameCount, frameCountType);
		}

		// Token: 0x06000C05 RID: 3077 RVA: 0x0003B059 File Offset: 0x00039459
		public static IObservable<T> ThrottleFirstFrame<T>(this IObservable<T> source, int frameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			if (frameCount < 0)
			{
				throw new ArgumentOutOfRangeException("frameCount");
			}
			return new ThrottleFirstFrameObservable<T>(source, frameCount, frameCountType);
		}

		// Token: 0x06000C06 RID: 3078 RVA: 0x0003B075 File Offset: 0x00039475
		public static IObservable<T> TimeoutFrame<T>(this IObservable<T> source, int frameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			if (frameCount < 0)
			{
				throw new ArgumentOutOfRangeException("frameCount");
			}
			return new TimeoutFrameObservable<T>(source, frameCount, frameCountType);
		}

		// Token: 0x06000C07 RID: 3079 RVA: 0x0003B091 File Offset: 0x00039491
		public static IObservable<T> DelayFrameSubscription<T>(this IObservable<T> source, int frameCount, FrameCountType frameCountType = FrameCountType.Update)
		{
			if (frameCount < 0)
			{
				throw new ArgumentOutOfRangeException("frameCount");
			}
			return new DelayFrameSubscriptionObservable<T>(source, frameCount, frameCountType);
		}

		// Token: 0x06000C08 RID: 3080 RVA: 0x0003B0AD File Offset: 0x000394AD
		public static ObservableYieldInstruction<T> ToYieldInstruction<T>(this IObservable<T> source)
		{
			return new ObservableYieldInstruction<T>(source, true, CancellationToken.None);
		}

		// Token: 0x06000C09 RID: 3081 RVA: 0x0003B0BB File Offset: 0x000394BB
		public static ObservableYieldInstruction<T> ToYieldInstruction<T>(this IObservable<T> source, CancellationToken cancel)
		{
			return new ObservableYieldInstruction<T>(source, true, cancel);
		}

		// Token: 0x06000C0A RID: 3082 RVA: 0x0003B0C5 File Offset: 0x000394C5
		public static ObservableYieldInstruction<T> ToYieldInstruction<T>(this IObservable<T> source, bool throwOnError)
		{
			return new ObservableYieldInstruction<T>(source, throwOnError, CancellationToken.None);
		}

		// Token: 0x06000C0B RID: 3083 RVA: 0x0003B0D3 File Offset: 0x000394D3
		public static ObservableYieldInstruction<T> ToYieldInstruction<T>(this IObservable<T> source, bool throwOnError, CancellationToken cancel)
		{
			return new ObservableYieldInstruction<T>(source, throwOnError, cancel);
		}

		// Token: 0x06000C0C RID: 3084 RVA: 0x0003B0DD File Offset: 0x000394DD
		public static IEnumerator ToAwaitableEnumerator<T>(this IObservable<T> source, CancellationToken cancel = default(CancellationToken))
		{
			return source.ToAwaitableEnumerator(Stubs<T>.Ignore, Stubs.Throw, cancel);
		}

		// Token: 0x06000C0D RID: 3085 RVA: 0x0003B0F0 File Offset: 0x000394F0
		public static IEnumerator ToAwaitableEnumerator<T>(this IObservable<T> source, Action<T> onResult, CancellationToken cancel = default(CancellationToken))
		{
			return source.ToAwaitableEnumerator(onResult, Stubs.Throw, cancel);
		}

		// Token: 0x06000C0E RID: 3086 RVA: 0x0003B0FF File Offset: 0x000394FF
		public static IEnumerator ToAwaitableEnumerator<T>(this IObservable<T> source, Action<Exception> onError, CancellationToken cancel = default(CancellationToken))
		{
			return source.ToAwaitableEnumerator(Stubs<T>.Ignore, onError, cancel);
		}

		// Token: 0x06000C0F RID: 3087 RVA: 0x0003B110 File Offset: 0x00039510
		public static IEnumerator ToAwaitableEnumerator<T>(this IObservable<T> source, Action<T> onResult, Action<Exception> onError, CancellationToken cancel = default(CancellationToken))
		{
			ObservableYieldInstruction<T> enumerator = new ObservableYieldInstruction<T>(source, false, cancel);
			IEnumerator<T> e = enumerator;
			while (e.MoveNext() && !cancel.IsCancellationRequested)
			{
				yield return null;
			}
			if (cancel.IsCancellationRequested)
			{
				enumerator.Dispose();
				yield break;
			}
			if (enumerator.HasResult)
			{
				onResult(enumerator.Result);
			}
			else if (enumerator.HasError)
			{
				onError(enumerator.Error);
			}
			yield break;
		}

		// Token: 0x06000C10 RID: 3088 RVA: 0x0003B140 File Offset: 0x00039540
		public static Coroutine StartAsCoroutine<T>(this IObservable<T> source, CancellationToken cancel = default(CancellationToken))
		{
			return source.StartAsCoroutine(Stubs<T>.Ignore, Stubs.Throw, cancel);
		}

		// Token: 0x06000C11 RID: 3089 RVA: 0x0003B153 File Offset: 0x00039553
		public static Coroutine StartAsCoroutine<T>(this IObservable<T> source, Action<T> onResult, CancellationToken cancel = default(CancellationToken))
		{
			return source.StartAsCoroutine(onResult, Stubs.Throw, cancel);
		}

		// Token: 0x06000C12 RID: 3090 RVA: 0x0003B162 File Offset: 0x00039562
		public static Coroutine StartAsCoroutine<T>(this IObservable<T> source, Action<Exception> onError, CancellationToken cancel = default(CancellationToken))
		{
			return source.StartAsCoroutine(Stubs<T>.Ignore, onError, cancel);
		}

		// Token: 0x06000C13 RID: 3091 RVA: 0x0003B171 File Offset: 0x00039571
		public static Coroutine StartAsCoroutine<T>(this IObservable<T> source, Action<T> onResult, Action<Exception> onError, CancellationToken cancel = default(CancellationToken))
		{
			return MainThreadDispatcher.StartCoroutine(source.ToAwaitableEnumerator(onResult, onError, cancel));
		}

		// Token: 0x06000C14 RID: 3092 RVA: 0x0003B181 File Offset: 0x00039581
		public static IObservable<T> ObserveOnMainThread<T>(this IObservable<T> source)
		{
			return source.ObserveOn(Scheduler.MainThread);
		}

		// Token: 0x06000C15 RID: 3093 RVA: 0x0003B190 File Offset: 0x00039590
		public static IObservable<T> ObserveOnMainThread<T>(this IObservable<T> source, MainThreadDispatchType dispatchType)
		{
			switch (dispatchType)
			{
			case MainThreadDispatchType.Update:
				return source.ObserveOnMainThread<T>();
			case MainThreadDispatchType.FixedUpdate:
				return source.SelectMany((T _) => Observable.EveryFixedUpdate().Take(1), (T x, long _) => x);
			case MainThreadDispatchType.EndOfFrame:
				return source.SelectMany((T _) => Observable.EveryEndOfFrame().Take(1), (T x, long _) => x);
			case MainThreadDispatchType.GameObjectUpdate:
				return source.SelectMany((T _) => MainThreadDispatcher.UpdateAsObservable().Take(1), (T x, Unit _) => x);
			case MainThreadDispatchType.LateUpdate:
				return source.SelectMany((T _) => MainThreadDispatcher.LateUpdateAsObservable().Take(1), (T x, Unit _) => x);
			case MainThreadDispatchType.AfterUpdate:
				return source.SelectMany((T _) => Observable.EveryAfterUpdate().Take(1), (T x, long _) => x);
			default:
				throw new ArgumentException("type is invalid");
			}
		}

		// Token: 0x06000C16 RID: 3094 RVA: 0x0003B26C File Offset: 0x0003966C
		public static IObservable<T> SubscribeOnMainThread<T>(this IObservable<T> source)
		{
			return source.SubscribeOn(Scheduler.MainThread);
		}

		// Token: 0x06000C17 RID: 3095 RVA: 0x0003B279 File Offset: 0x00039679
		public static IObservable<bool> EveryApplicationPause()
		{
			return MainThreadDispatcher.OnApplicationPauseAsObservable().AsObservable<bool>();
		}

		// Token: 0x06000C18 RID: 3096 RVA: 0x0003B285 File Offset: 0x00039685
		public static IObservable<bool> EveryApplicationFocus()
		{
			return MainThreadDispatcher.OnApplicationFocusAsObservable().AsObservable<bool>();
		}

		// Token: 0x06000C19 RID: 3097 RVA: 0x0003B291 File Offset: 0x00039691
		public static IObservable<Unit> OnceApplicationQuit()
		{
			return MainThreadDispatcher.OnApplicationQuitAsObservable().Take(1);
		}

		// Token: 0x06000C1A RID: 3098 RVA: 0x0003B29E File Offset: 0x0003969E
		public static IObservable<T> TakeUntilDestroy<T>(this IObservable<T> source, Component target)
		{
			return source.TakeUntil(target.OnDestroyAsObservable());
		}

		// Token: 0x06000C1B RID: 3099 RVA: 0x0003B2AC File Offset: 0x000396AC
		public static IObservable<T> TakeUntilDestroy<T>(this IObservable<T> source, GameObject target)
		{
			return source.TakeUntil(target.OnDestroyAsObservable());
		}

		// Token: 0x06000C1C RID: 3100 RVA: 0x0003B2BA File Offset: 0x000396BA
		public static IObservable<T> TakeUntilDisable<T>(this IObservable<T> source, Component target)
		{
			return source.TakeUntil(target.OnDisableAsObservable());
		}

		// Token: 0x06000C1D RID: 3101 RVA: 0x0003B2C8 File Offset: 0x000396C8
		public static IObservable<T> TakeUntilDisable<T>(this IObservable<T> source, GameObject target)
		{
			return source.TakeUntil(target.OnDisableAsObservable());
		}

		// Token: 0x06000C1E RID: 3102 RVA: 0x0003B2D6 File Offset: 0x000396D6
		public static IObservable<T> RepeatUntilDestroy<T>(this IObservable<T> source, GameObject target)
		{
			return Observable.RepeatInfinite<T>(source).RepeatUntilCore(target.OnDestroyAsObservable(), target);
		}

		// Token: 0x06000C1F RID: 3103 RVA: 0x0003B2EA File Offset: 0x000396EA
		public static IObservable<T> RepeatUntilDestroy<T>(this IObservable<T> source, Component target)
		{
			return Observable.RepeatInfinite<T>(source).RepeatUntilCore(target.OnDestroyAsObservable(), (!(target != null)) ? null : target.gameObject);
		}

		// Token: 0x06000C20 RID: 3104 RVA: 0x0003B315 File Offset: 0x00039715
		public static IObservable<T> RepeatUntilDisable<T>(this IObservable<T> source, GameObject target)
		{
			return Observable.RepeatInfinite<T>(source).RepeatUntilCore(target.OnDisableAsObservable(), target);
		}

		// Token: 0x06000C21 RID: 3105 RVA: 0x0003B329 File Offset: 0x00039729
		public static IObservable<T> RepeatUntilDisable<T>(this IObservable<T> source, Component target)
		{
			return Observable.RepeatInfinite<T>(source).RepeatUntilCore(target.OnDisableAsObservable(), (!(target != null)) ? null : target.gameObject);
		}

		// Token: 0x06000C22 RID: 3106 RVA: 0x0003B354 File Offset: 0x00039754
		private static IObservable<T> RepeatUntilCore<T>(this IEnumerable<IObservable<T>> sources, IObservable<Unit> trigger, GameObject lifeTimeChecker)
		{
			return new RepeatUntilObservable<T>(sources, trigger, lifeTimeChecker);
		}

		// Token: 0x06000C23 RID: 3107 RVA: 0x0003B35E File Offset: 0x0003975E
		public static IObservable<FrameInterval<T>> FrameInterval<T>(this IObservable<T> source)
		{
			return new FrameIntervalObservable<T>(source);
		}

		// Token: 0x06000C24 RID: 3108 RVA: 0x0003B366 File Offset: 0x00039766
		public static IObservable<TimeInterval<T>> FrameTimeInterval<T>(this IObservable<T> source, bool ignoreTimeScale = false)
		{
			return new FrameTimeIntervalObservable<T>(source, ignoreTimeScale);
		}

		// Token: 0x06000C25 RID: 3109 RVA: 0x0003B36F File Offset: 0x0003976F
		public static IObservable<IList<T>> BatchFrame<T>(this IObservable<T> source)
		{
			return source.BatchFrame(0, FrameCountType.EndOfFrame);
		}

		// Token: 0x06000C26 RID: 3110 RVA: 0x0003B379 File Offset: 0x00039779
		public static IObservable<IList<T>> BatchFrame<T>(this IObservable<T> source, int frameCount, FrameCountType frameCountType)
		{
			if (frameCount < 0)
			{
				throw new ArgumentException("frameCount must be >= 0, frameCount:" + frameCount);
			}
			return new BatchFrameObservable<T>(source, frameCount, frameCountType);
		}

		// Token: 0x06000C27 RID: 3111 RVA: 0x0003B3A0 File Offset: 0x000397A0
		public static IObservable<Unit> BatchFrame(this IObservable<Unit> source)
		{
			return source.BatchFrame(0, FrameCountType.EndOfFrame);
		}

		// Token: 0x06000C28 RID: 3112 RVA: 0x0003B3AA File Offset: 0x000397AA
		public static IObservable<Unit> BatchFrame(this IObservable<Unit> source, int frameCount, FrameCountType frameCountType)
		{
			if (frameCount < 0)
			{
				throw new ArgumentException("frameCount must be >= 0, frameCount:" + frameCount);
			}
			return new BatchFrameObservable(source, frameCount, frameCountType);
		}

		// Token: 0x040006FA RID: 1786
		private static readonly TimeSpan InfiniteTimeSpan = new TimeSpan(0, 0, 0, 0, -1);

		// Token: 0x040006FB RID: 1787
		private static readonly HashSet<Type> YieldInstructionTypes = new HashSet<Type>
		{
			typeof(WWW),
			typeof(WaitForEndOfFrame),
			typeof(WaitForFixedUpdate),
			typeof(WaitForSeconds),
			typeof(AsyncOperation),
			typeof(Coroutine)
		};

		// Token: 0x040006FC RID: 1788
		[CompilerGenerated]
		private static Func<IObserver<long>, CancellationToken, IEnumerator> callback0;

		// Token: 0x040006FD RID: 1789
		[CompilerGenerated]
		private static Func<IObserver<long>, CancellationToken, IEnumerator> callback1;

		// Token: 0x040006FE RID: 1790
		[CompilerGenerated]
		private static Func<IObserver<long>, CancellationToken, IEnumerator> callback2;

		// Token: 0x04000702 RID: 1794
		[CompilerGenerated]
		private static Func<IObserver<Unit>, CancellationToken, IEnumerator> callback3;

		// Token: 0x0200038D RID: 909
		private class ConnectableObservable<T> : IConnectableObservable<T>, IObservable<T>
		{
			// Token: 0x06001280 RID: 4736 RVA: 0x0003B4C7 File Offset: 0x000398C7
			public ConnectableObservable(IObservable<T> source, ISubject<T> subject)
			{
				this.source = source.AsObservable<T>();
				this.subject = subject;
			}

			// Token: 0x06001281 RID: 4737 RVA: 0x0003B4F0 File Offset: 0x000398F0
			public IDisposable Connect()
			{
				object obj = this.gate;
				IDisposable result;
				lock (obj)
				{
					if (this.connection == null)
					{
						IDisposable subscription = this.source.Subscribe(this.subject);
						this.connection = new Observable.ConnectableObservable<T>.Connection(this, subscription);
					}
					result = this.connection;
				}
				return result;
			}

			// Token: 0x06001282 RID: 4738 RVA: 0x0003B558 File Offset: 0x00039958
			public IDisposable Subscribe(IObserver<T> observer)
			{
				return this.subject.Subscribe(observer);
			}

			// Token: 0x04000B22 RID: 2850
			private readonly IObservable<T> source;

			// Token: 0x04000B23 RID: 2851
			private readonly ISubject<T> subject;

			// Token: 0x04000B24 RID: 2852
			private readonly object gate = new object();

			// Token: 0x04000B25 RID: 2853
			private Observable.ConnectableObservable<T>.Connection connection;

			// Token: 0x0200038E RID: 910
			private class Connection : IDisposable
			{
				// Token: 0x06001283 RID: 4739 RVA: 0x0003B566 File Offset: 0x00039966
				public Connection(Observable.ConnectableObservable<T> parent, IDisposable subscription)
				{
					this.parent = parent;
					this.subscription = subscription;
				}

				// Token: 0x06001284 RID: 4740 RVA: 0x0003B57C File Offset: 0x0003997C
				public void Dispose()
				{
					object gate = this.parent.gate;
					lock (gate)
					{
						if (this.subscription != null)
						{
							this.subscription.Dispose();
							this.subscription = null;
							this.parent.connection = null;
						}
					}
				}

				// Token: 0x04000B26 RID: 2854
				private readonly Observable.ConnectableObservable<T> parent;

				// Token: 0x04000B27 RID: 2855
				private IDisposable subscription;
			}
		}

		// Token: 0x020003DD RID: 989
		private class EveryAfterUpdateInvoker : IEnumerator
		{
			// Token: 0x0600143E RID: 5182 RVA: 0x0003B5E0 File Offset: 0x000399E0
			public EveryAfterUpdateInvoker(IObserver<long> observer, CancellationToken cancellationToken)
			{
				this.observer = observer;
				this.cancellationToken = cancellationToken;
			}

			// Token: 0x0600143F RID: 5183 RVA: 0x0003B600 File Offset: 0x00039A00
			public bool MoveNext()
			{
				if (!this.cancellationToken.IsCancellationRequested)
				{
					if (this.count != -1L)
					{
						IObserver<long> observer = this.observer;
						long value;
						this.count = (value = this.count) + 1L;
						observer.OnNext(value);
					}
					else
					{
						this.count += 1L;
					}
					return true;
				}
				return false;
			}

			// Token: 0x1700017D RID: 381
			// (get) Token: 0x06001440 RID: 5184 RVA: 0x0003B661 File Offset: 0x00039A61
			public object Current
			{
				get
				{
					return null;
				}
			}

			// Token: 0x06001441 RID: 5185 RVA: 0x0003B664 File Offset: 0x00039A64
			public void Reset()
			{
				throw new NotSupportedException();
			}

			// Token: 0x04000BB9 RID: 3001
			private long count = -1L;

			// Token: 0x04000BBA RID: 3002
			private readonly IObserver<long> observer;

			// Token: 0x04000BBB RID: 3003
			private readonly CancellationToken cancellationToken;
		}
	}
}
